def parse_type_dec(line, lineno, var_name, type_spec):
"""Constructs a L{ast_extensions.TypeDec} from the type declaration in the
provided line. The name of the variable and the name of the type are passed
since they are stored when matching the typedec regex against the line and
it would be wasteful to discard that information.
@type line: str
@param line: the line of source code containing the type declaration.
@type lineno: int
@param lineno: the index of this line in the orginial source code file.
@type var_name: str
@param var_name: the name of the identifier whose type is being declared.
@type type_name: str
@param type_name: the name of the type which is being declared.
@rtype: L{ast_extensions.TypeDec}
@return: a L{ast_extensions.TypeDec} node for the declaration in the given
line.
"""
col = line.index(var_name)
name_node = ast.Name(ctx=TypeStore(), id=var_name, lineno=lineno,
col_offset=col)
col_offset = line.index("#:")
return TypeDec([name_node], TypeSpecParser.parse(type_spec), lineno,
col_offset)
def __init__(self, targets, t, line, col = None):
"""Creates a L{TypeDec} node with the supplied parameters.
@type targets: list of ast.Name
@param targets: The list of variables which are having their types
declared.
@type t: PytyType
@param t: The type which the C{targets} are declared as. If a string is
provided, then a PytyType object will be created based on this
string.
@type line: int
@param line: The line number of the source code for the declaration.
@type col: int
@param col: The column number of the source code for the declaration.
"""
self.targets = targets
self.lineno = line
if col is not None:
self.col_offset = col
if type(t) == str:
self.t = TypeSpecParser.parse(t)
else:
self.t = t
# these are instance variables provided by AST nodes to allow traversal
# / parsing of the nodes.
self._fields = ("targets", "t")
self._attributes = ("lineno", "col_offset")
def make_function_tdec(partypes, rtype, lineno, func_name):
# FIXME: this should be somehow built into the parser; this is a hack.
t = TypeSpecParser.parse("(" + ', '.join(partype) + ") -> " + rtype)
return TypeDec([func_name], t, lineno)
