cargo: builder: Remove all duplicated functions

Keep only the Builder class, there is no point in duplicating
everything.

1 files changed, 43 insertions, 175 deletions

diff --git a/mesonbuild/cargo/builder.py b/mesonbuild/cargo/builder.py
index 3f7f6885e..66fd00c27 100644
--- a/mesonbuild/cargo/builder.py
+++ b/mesonbuild/cargo/builder.py
@@ -17,175 +17,26 @@ if T.TYPE_CHECKING:
     import builtins
 
 
-def _token(tid: str, filename: str, value: mparser.TV_TokenTypes) -> mparser.Token[mparser.TV_TokenTypes]:
-    """Create a Token object, but with the line numbers stubbed out.
-
-    :param tid: the token id (such as string, number, etc)
-    :param filename: the filename that the token was generated from
-    :param value: the value of the token
-    :return: A Token object
-    """
-    return mparser.Token(tid, filename, -1, -1, -1, (-1, -1), value)
-
-
-def _symbol(filename: str, val: str) -> mparser.SymbolNode:
-    return mparser.SymbolNode(_token('', filename, val))
-
-
-def string(value: str, filename: str) -> mparser.StringNode:
-    """Build A StringNode
-
-    :param value: the value of the string
-    :param filename: the file that the value came from
-    :return: A StringNode
-    """
-    return mparser.StringNode(_token('string', filename, value))
-
-
-def number(value: int, filename: str) -> mparser.NumberNode:
-    """Build A NumberNode
-
-    :param value: the value of the number
-    :param filename: the file that the value came from
-    :return: A NumberNode
-    """
-    return mparser.NumberNode(_token('number', filename, str(value)))
-
-
-def bool(value: builtins.bool, filename: str) -> mparser.BooleanNode:
-    """Build A BooleanNode
-
-    :param value: the value of the boolean
-    :param filename: the file that the value came from
-    :return: A BooleanNode
-    """
-    return mparser.BooleanNode(_token('bool', filename, value))
-
-
-def array(value: T.List[mparser.BaseNode], filename: str) -> mparser.ArrayNode:
-    """Build an Array Node
-
-    :param value: A list of nodes to insert into the array
-    :param filename: The file the array is from
-    :return: An ArrayNode built from the arguments
-    """
-    args = mparser.ArgumentNode(_token('array', filename, 'unused'))
-    args.arguments = value
-    return mparser.ArrayNode(_symbol(filename, '['), args, _symbol(filename, ']'))
-
-
-def identifier(value: str, filename: str) -> mparser.IdNode:
-    """Build A IdNode
-
-    :param value: the value of the boolean
-    :param filename: the file that the value came from
-    :return: A BooleanNode
-    """
-    return mparser.IdNode(_token('id', filename, value))
-
-
-def method(name: str, id_: mparser.IdNode,
-           pos: T.Optional[T.List[mparser.BaseNode]] = None,
-           kw: T.Optional[T.Mapping[str, mparser.BaseNode]] = None,
-           ) -> mparser.MethodNode:
-    """Create a method call.
-
-    :param name: the name of the method
-    :param id_: the object to call the method of
-    :param pos: a list of positional arguments, defaults to None
-    :param kw: a dictionary of keyword arguments, defaults to None
-    :return: a method call object
-    """
-    args = mparser.ArgumentNode(_token('array', id_.filename, 'unused'))
-    if pos is not None:
-        args.arguments = pos
-    if kw is not None:
-        args.kwargs = {identifier(k, id_.filename): v for k, v in kw.items()}
-    return mparser.MethodNode(id_, _symbol(id_.filename, '.'), identifier(name, id_.filename), _symbol(id_.filename, '('), args, _symbol(id_.filename, ')'))
-
-
-def function(name: str, filename: str,
-             pos: T.Optional[T.List[mparser.BaseNode]] = None,
-             kw: T.Optional[T.Mapping[str, mparser.BaseNode]] = None,
-             ) -> mparser.FunctionNode:
-    """Create a function call.
-
-    :param name: the name of the function
-    :param filename: The name of the current file being evaluated
-    :param pos: a list of positional arguments, defaults to None
-    :param kw: a dictionary of keyword arguments, defaults to None
-    :return: a method call object
-    """
-    args = mparser.ArgumentNode(_token('array', filename, 'unused'))
-    if pos is not None:
-        args.arguments = pos
-    if kw is not None:
-        args.kwargs = {identifier(k, filename): v for k, v in kw.items()}
-    return mparser.FunctionNode(identifier(name, filename), _symbol(filename, '('), args, _symbol(filename, ')'))
-
-
-def equal(lhs: mparser.BaseNode, rhs: mparser.BaseNode) -> mparser.ComparisonNode:
-    """Create an equality operation
-
-    :param lhs: The left hand side of the equal
-    :param rhs: the right hand side of the equal
-    :return: A compraison node
-    """
-    return mparser.ComparisonNode('==', lhs, _symbol(lhs.filename, '=='), rhs)
-
-
-def or_(lhs: mparser.BaseNode, rhs: mparser.BaseNode) -> mparser.OrNode:
-    """Create and OrNode
-
-    :param lhs: The Left of the Node
-    :param rhs: The Right of the Node
-    :return: The OrNode
-    """
-    return mparser.OrNode(lhs, _symbol(lhs.filename, 'or'), rhs)
-
-
-def and_(lhs: mparser.BaseNode, rhs: mparser.BaseNode) -> mparser.AndNode:
-    """Create an AndNode
-
-    :param lhs: The left of the And
-    :param rhs: The right of the And
-    :return: The AndNode
-    """
-    return mparser.AndNode(lhs, _symbol(lhs.filename, 'and'), rhs)
-
-
-def not_(value: mparser.BaseNode, filename: str) -> mparser.NotNode:
-    """Create a not node
-
-    :param value: The value to negate
-    :param filename: the string filename
-    :return: The NotNode
-    """
-    return mparser.NotNode(_token('not', filename, ''), _symbol(filename, 'not'), value)
-
-
-def assign(value: mparser.BaseNode, varname: str, filename: str) -> mparser.AssignmentNode:
-    """Create an AssignmentNode
-
-    :param value: The rvalue
-    :param varname: The lvalue
-    :param filename: The filename
-    :return: An AssignmentNode
-    """
-    return mparser.AssignmentNode(identifier(varname, filename), _symbol(filename, '='), value)
-
-
-def block(filename: str) -> mparser.CodeBlockNode:
-    return mparser.CodeBlockNode(_token('node', filename, ''))
-
-
 @dataclasses.dataclass
 class Builder:
 
     filename: str
 
+    def _token(self, tid: str, value: mparser.TV_TokenTypes) -> mparser.Token[mparser.TV_TokenTypes]:
+        """Create a Token object, but with the line numbers stubbed out.
+
+        :param tid: the token id (such as string, number, etc)
+        :param filename: the filename that the token was generated from
+        :param value: the value of the token
+        :return: A Token object
+        """
+        return mparser.Token(tid, self.filename, -1, -1, -1, (-1, -1), value)
+
+    def _symbol(self, val: str) -> mparser.SymbolNode:
+        return mparser.SymbolNode(self._token('', val))
+
     def assign(self, value: mparser.BaseNode, varname: str) -> mparser.AssignmentNode:
-        return assign(value, varname, self.filename)
+        return mparser.AssignmentNode(self.identifier(varname), self._symbol('='), value)
 
     def string(self, value: str) -> mparser.StringNode:
         """Build A StringNode
@@ -193,7 +44,7 @@ class Builder:
         :param value: the value of the string
         :return: A StringNode
         """
-        return string(value, self.filename)
+        return mparser.StringNode(self._token('string', value))
 
     def number(self, value: int) -> mparser.NumberNode:
         """Build A NumberNode
@@ -201,7 +52,7 @@ class Builder:
         :param value: the value of the number
         :return: A NumberNode
         """
-        return number(value, self.filename)
+        return mparser.NumberNode(self._token('number', str(value)))
 
     def bool(self, value: builtins.bool) -> mparser.BooleanNode:
         """Build A BooleanNode
@@ -209,7 +60,7 @@ class Builder:
         :param value: the value of the boolean
         :return: A BooleanNode
         """
-        return bool(value, self.filename)
+        return mparser.BooleanNode(self._token('bool', value))
 
     def array(self, value: T.List[mparser.BaseNode]) -> mparser.ArrayNode:
         """Build an Array Node
@@ -217,7 +68,9 @@ class Builder:
         :param value: A list of nodes to insert into the array
         :return: An ArrayNode built from the arguments
         """
-        return array(value, self.filename)
+        args = mparser.ArgumentNode(self._token('array', 'unused'))
+        args.arguments = value
+        return mparser.ArrayNode(self._symbol('['), args, self._symbol(']'))
 
     def identifier(self, value: str) -> mparser.IdNode:
         """Build A IdNode
@@ -225,7 +78,7 @@ class Builder:
         :param value: the value of the boolean
         :return: A BooleanNode
         """
-        return identifier(value, self.filename)
+        return mparser.IdNode(self._token('id', value))
 
     def method(self, name: str, id_: mparser.IdNode,
                pos: T.Optional[T.List[mparser.BaseNode]] = None,
@@ -239,7 +92,12 @@ class Builder:
         :param kw: a dictionary of keyword arguments, defaults to None
         :return: a method call object
         """
-        return method(name, id_, pos or [], kw or {})
+        args = mparser.ArgumentNode(self._token('array', 'unused'))
+        if pos is not None:
+            args.arguments = pos
+        if kw is not None:
+            args.kwargs = {self.identifier(k): v for k, v in kw.items()}
+        return mparser.MethodNode(id_, self._symbol('.'), self.identifier(name), self._symbol('('), args, self._symbol(')'))
 
     def function(self, name: str,
                  pos: T.Optional[T.List[mparser.BaseNode]] = None,
@@ -252,7 +110,12 @@ class Builder:
         :param kw: a dictionary of keyword arguments, defaults to None
         :return: a method call object
         """
-        return function(name, self.filename, pos or [], kw or {})
+        args = mparser.ArgumentNode(self._token('array', 'unused'))
+        if pos is not None:
+            args.arguments = pos
+        if kw is not None:
+            args.kwargs = {self.identifier(k): v for k, v in kw.items()}
+        return mparser.FunctionNode(self.identifier(name), self._symbol('('), args, self._symbol(')'))
 
     def equal(self, lhs: mparser.BaseNode, rhs: mparser.BaseNode) -> mparser.ComparisonNode:
         """Create an equality operation
@@ -261,7 +124,7 @@ class Builder:
         :param rhs: the right hand side of the equal
         :return: A compraison node
         """
-        return equal(lhs, rhs)
+        return mparser.ComparisonNode('==', lhs, self._symbol('=='), rhs)
 
     def or_(self, lhs: mparser.BaseNode, rhs: mparser.BaseNode) -> mparser.OrNode:
         """Create and OrNode
@@ -270,7 +133,7 @@ class Builder:
         :param rhs: The Right of the Node
         :return: The OrNode
         """
-        return or_(lhs, rhs)
+        return mparser.OrNode(lhs, self._symbol('or'), rhs)
 
     def and_(self, lhs: mparser.BaseNode, rhs: mparser.BaseNode) -> mparser.AndNode:
         """Create an AndNode
@@ -279,12 +142,17 @@ class Builder:
         :param rhs: The right of the And
         :return: The AndNode
         """
-        return and_(lhs, rhs)
+        return mparser.AndNode(lhs, self._symbol('and'), rhs)
 
-    def not_(self, value: mparser.BaseNode, filename: str) -> mparser.NotNode:
+    def not_(self, value: mparser.BaseNode) -> mparser.NotNode:
         """Create a not node
 
         :param value: The value to negate
         :return: The NotNode
         """
-        return not_(value, self.filename)
+        return mparser.NotNode(self._token('not', ''), self._symbol('not'), value)
+
+    def block(self, lines: T.List[mparser.BaseNode]) -> mparser.CodeBlockNode:
+        block = mparser.CodeBlockNode(self._token('node', ''))
+        block.lines = lines
+        return block