def resolve_type(self, type, must_resolve_all_generics):
if isinstance(type, astTypes.GenericsType):
resolved_type = self.resolution_map.get(type.type_var_name)
if resolved_type == None and must_resolve_all_generics:
raise Error(
f'''Could not resolve generics type: {type.repr()}''')
return resolved_type if resolved_type != None else type
elif isinstance(type, astTypes.ClassType):
return astTypes.ClassType(
type.decl,
list(
map(
lambda x: self.resolve_type(x,
must_resolve_all_generics),
type.type_arguments)))
elif isinstance(type, astTypes.InterfaceType):
return astTypes.InterfaceType(
type.decl,
list(
map(
lambda x: self.resolve_type(x,
must_resolve_all_generics),
type.type_arguments)))
elif isinstance(type, astTypes.LambdaType):
return astTypes.LambdaType(
list(
map(
lambda x: types.MethodParameter(
x.name,
self.resolve_type(x.type, must_resolve_all_generics
), x.initializer, None),
type.parameters)),
self.resolve_type(type.return_type, must_resolve_all_generics))
else:
return type
def handle_lambda(self, lambda_):
self.start()
self.main.process_lambda(lambda_)
lambda_.returns = self.finish(lambda_.returns, "Lambda", None)
lambda_.set_actual_type(
astTypes.LambdaType(lambda_.parameters, lambda_.returns), False,
True)
return True
def parse_type(self):
if self.reader.read_token("{"):
self.reader.expect_token("[")
self.reader.read_identifier()
self.reader.expect_token(":")
self.reader.expect_token("string")
self.reader.expect_token("]")
self.reader.expect_token(":")
map_value_type = self.parse_type()
self.reader.read_token(";")
self.reader.expect_token("}")
return astTypes.UnresolvedType("TsMap", [map_value_type])
if self.reader.peek_token("("):
params = self.parse_lambda_params()
self.reader.expect_token("=>")
return_type = self.parse_type()
return astTypes.LambdaType(params, return_type)
type_name = self.reader.expect_identifier()
start_pos = self.reader.prev_token_offset
if type_name == "string":
type = astTypes.UnresolvedType("TsString", [])
elif type_name == "boolean":
type = astTypes.UnresolvedType("TsBoolean", [])
elif type_name == "number":
type = astTypes.UnresolvedType("TsNumber", [])
elif type_name == "any":
type = astTypes.AnyType.instance
elif type_name == "void":
type = astTypes.VoidType.instance
else:
type_arguments = self.parse_type_args()
type = astTypes.UnresolvedType(type_name, type_arguments)
self.node_manager.add_node(type, start_pos)
while self.reader.read_token("[]"):
type = astTypes.UnresolvedType("TsArray", [type])
self.node_manager.add_node(type, start_pos)
return type