Implement new scope rules for type variables (issue 5230).

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 2301 matching lines @@
     // An identifier cannot be resolved in a local scope when top level parsing.
     if (is_top_level_ ||
         !ResolveIdentInLocalScope(qual_ident->ident_pos,
                                   *(qual_ident->ident),
                                   NULL)) {
       LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
       lib_prefix = current_class().LookupLibraryPrefix(*(qual_ident->ident));
       if (!lib_prefix.IsNull()) {
         // We have a library prefix qualified identifier, unless the prefix is
         // shadowed by a type parameter in scope.
-        const Class& scope_class = Class::Handle(TypeParametersScopeClass());
-        if (scope_class.IsNull() ||
-            (scope_class.LookupTypeParameter(*(qual_ident->ident),
-                                             TokenPos()) ==
+        if (current_class().IsNull() ||
+            (current_class().LookupTypeParameter(*(qual_ident->ident),
+                                                 TokenPos()) ==
              TypeParameter::null())) {
           ConsumeToken();  // Consume the kPERIOD token.
           qual_ident->lib_prefix = &lib_prefix;
           qual_ident->ident_pos = TokenPos();
           qual_ident->ident =
               ExpectIdentifier("identifier expected after '.'");
         }
       }
     }
   }
@@ skipping 5232 matching lines @@
     const String& unresolved_class_name =
         String::Handle(unresolved_class.ident());
     Class& resolved_type_class = Class::Handle();
     if (unresolved_class.library_prefix() == LibraryPrefix::null()) {
       if (!scope_class.IsNull()) {
         // 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,
                                             type->token_pos()));
         if (!type_parameter.IsNull()) {
+          // A type parameter is considered to be a malformed type when
+          // referenced by a static member.
+          if (ParsingStaticMember()) {
+            ASSERT(scope_class.raw() == current_class().raw());
+            *type = ClassFinalizer::NewFinalizedMalformedType(
+                scope_class,
+                type->token_pos(),
+                "type parameter '%s' cannot be referenced "
+                "from static member",
+                String::Handle(type_parameter.name()).ToCString());
+            return;
+          }
+          // TODO(regis): Should this be a malformed type as well?
           // 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_parameter.token_pos(),
                      "type parameter '%s' cannot be parameterized",
                      String::Handle(type_parameter.name()).ToCString());
           }
           *type = type_parameter.raw();
           return;
         }
@@ skipping 143 matching lines @@
   // Fields are not accessible from a static function, except from a
   // constructor, which is considered as non-static by the compiler.
   if (current_function().is_static()) {
     ErrorMsg(field_pos,
              "cannot access instance field '%s' from a static function",
              field_name.ToCString());
   }
 }
 
 
-// If type parameters are currently in scope, return their declaring class,
-// otherwise return null.
-RawClass* Parser::TypeParametersScopeClass() const {
-  // Type parameters cannot be referred to from a static function, except from
-  // a constructor or from a factory.
-  // A constructor is considered as non-static by the compiler.
+bool Parser::ParsingStaticMember() const {
   if (is_top_level_) {
-    if ((current_member_ == NULL) ||
-        (current_member_->has_factory || !current_member_->has_static)) {
-      return current_class().raw();
-    }
-  } else {
-    if (!current_function().IsNull()) {
-      Function& outer_function = Function::Handle(current_function().raw());
-      while (outer_function.IsLocalFunction()) {
-        outer_function = outer_function.parent_function();
-      }
-      if (outer_function.IsFactory() || !outer_function.is_static()) {
-        return current_class().raw();
-      }
-    }
+    return (current_member_ != NULL) &&
+           current_member_->has_static && !current_member_->has_factory;
   }
-  return Class::null();
+  ASSERT(!current_function().IsNull());
+  Function& outer_function = Function::Handle(current_function().raw());

[hausner, 2012/10/05 19:57:45]

You could have a special case where you don't allocate a handle when we're
parsing a non-nested function. That is probably the common case. Not sure
whether it's worth it.

[regis, 2012/10/05 20:28:40]

Good point.
I optimized Function::IsInFactoryScope instead and used it here and in
Parser::IsInstantiatorRequired.

+  while (outer_function.IsLocalFunction()) {
+    outer_function = outer_function.parent_function();
+  }
+  return outer_function.is_static() && !outer_function.IsFactory();
 }
 
 
 const Type* Parser::ReceiverType(intptr_t type_pos) const {
   ASSERT(!current_class().IsNull());
   TypeArguments& type_arguments = TypeArguments::Handle();
   if (current_class().NumTypeParameters() > 0) {
     type_arguments = current_class().type_parameters();
   }
   Type& type = Type::ZoneHandle(
@@ skipping 508 matching lines @@
                               const String& ident,
                               bool allow_closure_names) {
   TRACE_PARSER("ResolveIdent");
   // First try to find the variable in the local scope (block scope or
   // class scope).
   AstNode* resolved = NULL;
   ResolveIdentInLocalScope(ident_pos, ident, &resolved);
   if (resolved == NULL) {
     // Check whether the identifier is a type parameter. Type parameters
     // can never be used in primary expressions.
-    const Class& scope_class = Class::Handle(TypeParametersScopeClass());
-    if (!scope_class.IsNull()) {
+    if (!current_class().IsNull()) {
       TypeParameter& type_param = TypeParameter::Handle(
-          scope_class.LookupTypeParameter(ident, ident_pos));
+          current_class().LookupTypeParameter(ident, ident_pos));
       if (!type_param.IsNull()) {
         String& type_param_name = String::Handle(type_param.name());
         ErrorMsg(ident_pos, "illegal use of type parameter %s",
                  type_param_name.ToCString());
       }
     }
     // Not found in the local scope, and the name is not a type parameter.
     // Try finding the variable in the library scope (current library
     // and all libraries imported by it without a library prefix).
     resolved = ResolveIdentInCurrentLibraryScope(ident_pos, ident);
@@ skipping 73 matching lines @@
   // In production mode, malformed type arguments are mapped to Dynamic.
   // In checked mode, a type with malformed type arguments is malformed.
   if (FLAG_enable_type_checks && !malformed_error.IsNull()) {
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type.raw();
     parameterized_type.set_type_class(Class::Handle(Object::dynamic_class()));
     parameterized_type.set_arguments(AbstractTypeArguments::Handle());
     parameterized_type.set_malformed_error(malformed_error);
   }
   if (finalization >= ClassFinalizer::kTryResolve) {
-    const Class& scope_class = Class::Handle(TypeParametersScopeClass());
-    ResolveTypeFromClass(scope_class, finalization, &type);
+    ResolveTypeFromClass(current_class(), finalization, &type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
       type ^= ClassFinalizer::FinalizeType(current_class(), type, finalization);
     }
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     intptr_t pos, Function& constructor,
@@ skipping 884 matching lines @@
     CloseBlock();
   } else if (IsIdentifier()) {
     QualIdent qual_ident;
     ParseQualIdent(&qual_ident);
     if (qual_ident.lib_prefix == NULL) {
       if (!ResolveIdentInLocalScope(qual_ident.ident_pos,
                                     *qual_ident.ident,
                                     &primary)) {
         // Check whether the identifier is a type parameter. Type parameters
         // can never be used as part of primary expressions.
-        const Class& scope_class = Class::Handle(TypeParametersScopeClass());
-        if (!scope_class.IsNull()) {
+        if (!current_class().IsNull()) {
           TypeParameter& type_param = TypeParameter::ZoneHandle(
-              scope_class.LookupTypeParameter(*(qual_ident.ident),
-                                              TokenPos()));
+              current_class().LookupTypeParameter(*(qual_ident.ident),
+                                                  TokenPos()));
           if (!type_param.IsNull()) {
             const String& type_param_name = String::Handle(type_param.name());
             ErrorMsg(qual_ident.ident_pos,
                      "illegal use of type parameter %s",
                      type_param_name.ToCString());
           }
         }
         // This is a non-local unqualified identifier so resolve the
         // identifier locally in the main app library and all libraries
         // imported by it.
@@ skipping 390 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart