Index: runtime/vm/parser.cc |
=================================================================== |
--- runtime/vm/parser.cc (revision 3964) |
+++ runtime/vm/parser.cc (working copy) |
@@ -879,14 +879,8 @@ |
ASSERT(signature_function.signature_class() == signature_class.raw()); |
Type& signature_type = Type::ZoneHandle(signature_class.SignatureType()); |
if (!is_top_level_ && !signature_type.IsFinalized()) { |
- Error& error = Error::Handle(); |
signature_type ^= |
- ClassFinalizer::FinalizeAndCanonicalizeType(signature_class, |
- signature_type, |
- &error); |
- if (!error.IsNull()) { |
- ErrorMsg(error.ToErrorCString()); |
- } |
+ ClassFinalizer::FinalizeType(signature_class, signature_type); |
} |
// The type of the parameter is now the signature type. |
parameter.type = &signature_type; |
@@ -1925,7 +1919,8 @@ |
// shadowed by a type parameter in scope. |
const Class& scope_class = Class::Handle(TypeParametersScopeClass()); |
if (scope_class.IsNull() || |
- (scope_class.LookupTypeParameter(*(qual_ident->ident)) == |
+ (scope_class.LookupTypeParameter(*(qual_ident->ident), |
+ token_index_) == |
TypeParameter::null())) { |
ConsumeToken(); // Consume the kPERIOD token. |
qual_ident->lib_prefix = &lib_prefix; |
@@ -2336,8 +2331,9 @@ |
const Object& result_type_class = Object::Handle( |
LookupTypeClass(factory_name, kCanResolve)); |
// The type arguments of the result type are set during finalization. |
- member.type = &Type::ZoneHandle( |
- Type::New(result_type_class, TypeArguments::Handle())); |
+ member.type = &Type::ZoneHandle(Type::New(result_type_class, |
+ TypeArguments::Handle(), |
+ factory_name.ident_pos)); |
} else { |
member.name_pos = token_index_; |
member.name = CurrentLiteral(); |
@@ -2468,7 +2464,7 @@ |
Class& cls = Class::ZoneHandle(); |
Object& obj = Object::Handle(library_.LookupObject(class_name)); |
if (obj.IsNull()) { |
- cls = Class::New(class_name, script_); |
+ cls = Class::New(class_name, script_, classname_pos); |
library_.AddClass(cls); |
} else { |
if (!obj.IsClass()) { |
@@ -2627,14 +2623,14 @@ |
// constraints. Make it the owner of the function type descriptor. |
const Class& alias_owner = Class::Handle( |
Class::New(String::Handle(String::NewSymbol(":alias_owner")), |
- Script::Handle())); |
+ Script::Handle(), |
+ token_index_)); |
alias_owner.set_is_interface(); |
alias_owner.set_library(library_); |
set_current_class(alias_owner); |
// Parse the result type of the function type. |
AbstractType& result_type = Type::Handle(Type::DynamicType()); |
- const intptr_t result_type_pos = token_index_; |
if (CurrentToken() == Token::kVOID) { |
ConsumeToken(); |
result_type = Type::VoidType(); |
@@ -2653,10 +2649,7 @@ |
// At this point, the type parameters have been parsed, so we can resolve the |
// result type. |
if (!result_type.IsNull()) { |
- ResolveTypeFromClass(result_type_pos, |
- alias_owner, |
- kCanResolve, |
- &result_type); |
+ ResolveTypeFromClass(alias_owner, kCanResolve, &result_type); |
} |
// Parse the formal parameters of the function type. |
if (CurrentToken() != Token::kLPAREN) { |
@@ -2727,7 +2720,7 @@ |
Class& interface = Class::ZoneHandle(); |
Object& obj = Object::Handle(library_.LookupObject(interface_name)); |
if (obj.IsNull()) { |
- interface = Class::NewInterface(interface_name, script_); |
+ interface = Class::NewInterface(interface_name, script_, interfacename_pos); |
library_.AddClass(interface); |
} else { |
if (!obj.IsClass()) { |
@@ -2762,7 +2755,6 @@ |
if (CurrentToken() != Token::kIDENT) { |
ErrorMsg("class name expected"); |
} |
- const intptr_t factory_pos = token_index_; |
QualIdent factory_name; |
ParseQualIdent(&factory_name); |
LibraryPrefix& lib_prefix = LibraryPrefix::Handle(); |
@@ -2770,10 +2762,13 @@ |
lib_prefix = factory_name.lib_prefix->raw(); |
} |
const UnresolvedClass& unresolved_factory_class = UnresolvedClass::Handle( |
- UnresolvedClass::New(factory_pos, lib_prefix, *factory_name.ident)); |
+ UnresolvedClass::New(lib_prefix, |
+ *factory_name.ident, |
+ factory_name.ident_pos)); |
const Class& factory_class = Class::Handle( |
Class::New(String::Handle(String::NewSymbol(":factory_signature")), |
- script_)); |
+ script_, |
+ factory_name.ident_pos)); |
factory_class.set_library(library_); |
factory_class.set_is_finalized(); |
ParseTypeParameters(factory_class); |
@@ -2800,12 +2795,11 @@ |
} |
if (mismatch) { |
const String& interface_name = String::Handle(interface.Name()); |
- const String& factory_name = String::Handle(factory_class.Name()); |
- ErrorMsg(factory_pos, |
+ ErrorMsg(factory_name.ident_pos, |
"mismatch in number or names of type parameters between " |
"interface '%s' and default factory class '%s'.\n", |
interface_name.ToCString(), |
- factory_name.ToCString()); |
+ factory_name.ident->ToCString()); |
} |
} |
} |
@@ -2876,7 +2870,6 @@ |
void Parser::ParseTypeParameters(const Class& cls) { |
if (CurrentToken() == Token::kLT) { |
- const intptr_t type_pos = token_index_; |
GrowableArray<String*> type_parameters; |
GrowableArray<AbstractType*> type_parameter_extends; |
do { |
@@ -2910,7 +2903,7 @@ |
const intptr_t num_types = extends_array.Length(); |
for (intptr_t i = 0; i < num_types; i++) { |
type_extends = extends_array.TypeAt(i); |
- ResolveTypeFromClass(type_pos, cls, kCanResolve, &type_extends); |
+ ResolveTypeFromClass(cls, kCanResolve, &type_extends); |
extends_array.SetTypeAt(i, type_extends); |
} |
} |
@@ -3351,7 +3344,9 @@ |
is_top_level_ = true; |
TopLevel top_level; |
Class& toplevel_class = Class::ZoneHandle( |
- Class::New(String::ZoneHandle(String::NewSymbol("::")), script_)); |
+ Class::New(String::ZoneHandle(String::NewSymbol("::")), |
+ script_, |
+ token_index_)); |
toplevel_class.set_library(library_); |
if (is_library_source()) { |
@@ -3753,7 +3748,8 @@ |
// We temporarily use the class of the Function interface. |
const Class& unknown_signature_class = Class::Handle( |
Type::Handle(Type::FunctionInterface()).type_class()); |
- function_type = Type::New(unknown_signature_class, TypeArguments::Handle()); |
+ function_type = Type::New( |
+ unknown_signature_class, TypeArguments::Handle(), ident_pos); |
function_type.set_is_finalized(); // No real finalization needed. |
// Add the function variable to the scope before parsing the function in |
@@ -3812,15 +3808,9 @@ |
// Since the signature type is cached by the signature class, it may have |
// been finalized already. |
if (!signature_type.IsFinalized()) { |
- Error& error = Error::Handle(); |
signature_type ^= |
- ClassFinalizer::FinalizeAndCanonicalizeType(signature_class, |
- signature_type, |
- &error); |
- if (!error.IsNull()) { |
- ErrorMsg(error.ToErrorCString()); |
- } |
- // The call to ClassFinalizer::FinalizeAndCanonicalizeType may have |
+ ClassFinalizer::FinalizeType(signature_class, signature_type); |
+ // The call to ClassFinalizer::FinalizeType may have |
// extended the vector of type arguments. |
ASSERT(signature_type_arguments.IsNull() || |
(signature_type_arguments.Length() == |
@@ -6158,8 +6148,7 @@ |
// Not all involved type classes may get resolved yet, but at least the type |
// parameters of the given class will get resolved, thereby relieving the class |
// finalizer from resolving type parameters out of context. |
-void Parser::ResolveTypeFromClass(intptr_t type_pos, |
- const Class& scope_class, |
+void Parser::ResolveTypeFromClass(const Class& scope_class, |
TypeResolution type_resolution, |
AbstractType* type) { |
ASSERT((type_resolution == kCanResolve) || (type_resolution == kMustResolve)); |
@@ -6179,12 +6168,14 @@ |
lib = scope_class.library(); |
// First check if the type is a type parameter of the given scope class. |
const TypeParameter& type_parameter = TypeParameter::Handle( |
- scope_class.LookupTypeParameter(unresolved_class_name)); |
+ scope_class.LookupTypeParameter(unresolved_class_name, |
+ type->token_index())); |
if (!type_parameter.IsNull()) { |
// A type parameter cannot be parameterized, so report an error if |
// type arguments have previously been parsed. |
if (!AbstractTypeArguments::Handle(type->arguments()).IsNull()) { |
- ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized", |
+ ErrorMsg(type_parameter.token_index(), |
+ "type parameter '%s' cannot be parameterized", |
String::Handle(type_parameter.Name()).ToCString()); |
} |
*type = type_parameter.raw(); |
@@ -6207,7 +6198,7 @@ |
parameterized_type ^= type->raw(); |
parameterized_type.set_type_class(type_class); |
} else if (type_resolution == kMustResolve) { |
- ErrorMsg(type_pos, "type '%s' is not loaded", |
+ ErrorMsg(type->token_index(), "type '%s' is not loaded", |
String::Handle(type->Name()).ToCString()); |
} |
} |
@@ -6219,8 +6210,7 @@ |
const intptr_t num_arguments = arguments.Length(); |
for (intptr_t i = 0; i < num_arguments; i++) { |
AbstractType& type_argument = AbstractType::Handle(arguments.TypeAt(i)); |
- ResolveTypeFromClass(type_pos, |
- scope_class, |
+ ResolveTypeFromClass(scope_class, |
type_resolution, |
&type_argument); |
arguments.SetTypeAt(i, type_argument); |
@@ -6256,9 +6246,9 @@ |
if (type_name.lib_prefix != NULL) { |
lib_prefix = type_name.lib_prefix->raw(); |
} |
- return UnresolvedClass::New(type_name.ident_pos, |
- lib_prefix, |
- *type_name.ident); |
+ return UnresolvedClass::New(lib_prefix, |
+ *type_name.ident, |
+ type_name.ident_pos); |
} |
@@ -6665,7 +6655,6 @@ |
ErrorMsg("type name expected"); |
} |
QualIdent type_name; |
- const intptr_t type_pos = token_index_; |
if (type_resolution == kIgnore) { |
SkipQualIdent(); |
} else { |
@@ -6673,8 +6662,8 @@ |
// An identifier cannot be resolved in a local scope when top level parsing. |
if (!is_top_level_ && |
(type_name.lib_prefix == NULL) && |
- ResolveIdentInLocalScope(type_pos, *type_name.ident, NULL)) { |
- ErrorMsg(type_pos, "using '%s' in this context is invalid", |
+ ResolveIdentInLocalScope(type_name.ident_pos, *type_name.ident, NULL)) { |
+ ErrorMsg(type_name.ident_pos, "using '%s' in this context is invalid", |
type_name.ident->ToCString()); |
} |
} |
@@ -6687,7 +6676,9 @@ |
if (type_name.lib_prefix != NULL) { |
lib_prefix = type_name.lib_prefix->raw(); |
} |
- type_class = UnresolvedClass::New(type_pos, lib_prefix, *type_name.ident); |
+ type_class = UnresolvedClass::New(lib_prefix, |
+ *type_name.ident, |
+ type_name.ident_pos); |
} else { |
// TODO(regis): Use ResolveTypeFromClass(). |
ASSERT((type_resolution == kCanResolve) || |
@@ -6697,22 +6688,18 @@ |
if (type_name.lib_prefix == NULL) { |
// Check if ident is a type parameter in scope. |
TypeParameter& type_parameter = TypeParameter::Handle( |
- scope_class.LookupTypeParameter(*type_name.ident)); |
+ scope_class.LookupTypeParameter(*type_name.ident, |
+ type_name.ident_pos)); |
if (!type_parameter.IsNull()) { |
if (CurrentToken() == Token::kLT) { |
// A type parameter cannot be parameterized. |
- ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized", |
+ ErrorMsg(type_parameter.token_index(), |
+ "type parameter '%s' cannot be parameterized", |
String::Handle(type_parameter.Name()).ToCString()); |
} |
if (type_resolution == kMustResolve) { |
- Error& error = Error::Handle(); |
type_parameter ^= |
- ClassFinalizer::FinalizeAndCanonicalizeType(scope_class, |
- type_parameter, |
- &error); |
- if (!error.IsNull()) { |
- ErrorMsg(error.ToErrorCString()); |
- } |
+ ClassFinalizer::FinalizeType(current_class(), type_parameter); |
} |
return type_parameter.raw(); |
} |
@@ -6726,16 +6713,11 @@ |
if (type_resolution == kIgnore) { |
return Type::DynamicType(); |
} |
- Type& type = Type::Handle(Type::New(type_class, type_arguments)); |
+ Type& type = Type::Handle( |
+ Type::New(type_class, type_arguments, type_name.ident_pos)); |
if (type_resolution == kMustResolve) { |
ASSERT(type_class.IsClass()); // Must be resolved. |
- Error& error = Error::Handle(); |
- type ^= ClassFinalizer::FinalizeAndCanonicalizeType(scope_class, |
- type, |
- &error); |
- if (!error.IsNull()) { |
- ErrorMsg(error.ToErrorCString()); |
- } |
+ type ^= ClassFinalizer::FinalizeType(current_class(), type); |
} |
return type.raw(); |
} |
@@ -7137,8 +7119,8 @@ |
const AbstractType& type = AbstractType::Handle(ParseType(kMustResolve)); |
if (type.IsTypeParameter()) { |
- // TODO(regis): Use type position once supported. |
- ErrorMsg(new_pos, "type parameter '%s' cannot be instantiated", |
+ ErrorMsg(type.token_index(), |
+ "type parameter '%s' cannot be instantiated", |
String::Handle(type.Name()).ToCString()); |
} |
Class& type_class = Class::Handle(type.type_class()); |
@@ -7183,12 +7165,14 @@ |
Function& constructor = Function::ZoneHandle( |
type_class.LookupConstructor(constructor_name)); |
if (constructor.IsNull()) { |
- ErrorMsg(new_pos, "interface '%s' has no constructor named '%s'", |
+ ErrorMsg(type.token_index(), |
+ "interface '%s' has no constructor named '%s'", |
type_class_name.ToCString(), |
external_constructor_name.ToCString()); |
} |
if (!constructor.AreValidArguments(arguments_length, arguments->names())) { |
- ErrorMsg(new_pos, "invalid arguments passed to constructor '%s' " |
+ ErrorMsg(type.token_index(), |
+ "invalid arguments passed to constructor '%s' " |
"for interface '%s'", |
external_constructor_name.ToCString(), |
type_class_name.ToCString()); |
@@ -7233,15 +7217,16 @@ |
if (constructor.IsNull()) { |
const String& external_constructor_name = |
(named_constructor ? constructor_name : constructor_class_name); |
- ErrorMsg(new_pos, "class '%s' has no constructor or factory named '%s'", |
+ ErrorMsg(type.token_index(), |
+ "class '%s' has no constructor or factory named '%s'", |
String::Handle(constructor_class.Name()).ToCString(), |
external_constructor_name.ToCString()); |
} |
if (!constructor.AreValidArguments(arguments_length, arguments->names())) { |
const String& external_constructor_name = |
(named_constructor ? constructor_name : constructor_class_name); |
- ErrorMsg(new_pos, "invalid arguments passed to constructor '%s' " |
- "for class '%s'", |
+ ErrorMsg(type.token_index(), |
+ "invalid arguments passed to constructor '%s' for class '%s'", |
external_constructor_name.ToCString(), |
String::Handle(constructor_class.Name()).ToCString()); |
} |
@@ -7275,15 +7260,8 @@ |
} |
// TODO(regis): Temporary type should be allocated in new gen heap. |
Type& temp_type = Type::Handle( |
- Type::New(constructor_class, temp_type_arguments)); |
- Error& error = Error::Handle(); |
- const Class& scope_class = Class::Handle(TypeParametersScopeClass()); |
- temp_type ^= ClassFinalizer::FinalizeAndCanonicalizeType(scope_class, |
- temp_type, |
- &error); |
- if (!error.IsNull()) { |
- ErrorMsg(error.ToErrorCString()); |
- } |
+ Type::New(constructor_class, temp_type_arguments, type.token_index())); |
+ temp_type ^= ClassFinalizer::FinalizeType(current_class(), temp_type); |
// The type argument vector may have been expanded with the type arguments |
// of the super type when finalizing the temporary type. |
type_arguments = temp_type.arguments(); |