Handle wrong method invocation of a type parameter (fix issue 13134).

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 "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 8331 matching lines @@
 }
 
 
 AstNode* Parser::ParseSelectors(AstNode* primary, bool is_cascade) {
   AstNode* left = primary;
   while (true) {
     AstNode* selector = NULL;
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       if (left->IsPrimaryNode()) {
-        if (left->AsPrimaryNode()->primary().IsFunction()) {
-          left = LoadClosure(left->AsPrimaryNode());
-        } else if (left->AsPrimaryNode()->primary().IsTypeParameter()) {
+        PrimaryNode* primary_node = left->AsPrimaryNode();
+        const intptr_t primary_pos = primary_node->token_pos();
+        if (primary_node->primary().IsFunction()) {
+          left = LoadClosure(primary_node);
+        } else if (primary_node->primary().IsTypeParameter()) {
+          if (current_function().is_static()) {
+            const String& name = String::ZoneHandle(
+                TypeParameter::Cast(primary_node->primary()).name());
+            ErrorMsg(primary_pos,
+                     "cannot access type parameter '%s' from static function",
+                     name.ToCString());
+          }
           if (current_block_->scope->function_level() > 0) {
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
           TypeParameter& type_parameter = TypeParameter::ZoneHandle();
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
-              TypeParameter::Cast(left->AsPrimaryNode()->primary()),
+              TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
           left = new TypeNode(primary->token_pos(), type_parameter);
         } else {
           // Super field access handled in ParseSuperFieldAccess(),
           // super calls handled in ParseSuperCall().
-          ASSERT(!left->AsPrimaryNode()->IsSuper());
+          ASSERT(!primary_node->IsSuper());
           left = LoadFieldIfUnresolved(left);
         }
       }
       const intptr_t ident_pos = TokenPos();
       String* ident = ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kLPAREN) {
         // Identifier followed by a opening paren: method call.
         if (left->IsPrimaryNode() &&
             left->AsPrimaryNode()->primary().IsClass()) {
           // Static method call prefixed with class name.
@@ skipping 28 matching lines @@
 
       const intptr_t bracket_pos = TokenPos();
       ConsumeToken();
       left = LoadFieldIfUnresolved(left);
       const bool saved_mode = SetAllowFunctionLiterals(true);
       AstNode* index = ParseExpr(kAllowConst, kConsumeCascades);
       SetAllowFunctionLiterals(saved_mode);
       ExpectToken(Token::kRBRACK);
       AstNode* array = left;
       if (left->IsPrimaryNode()) {
-        PrimaryNode* primary = left->AsPrimaryNode();
-        if (primary->primary().IsFunction()) {
-          array = LoadClosure(primary);
-        } else if (primary->primary().IsClass()) {
-          const Class& type_class = Class::Cast(primary->primary());
+        PrimaryNode* primary_node = left->AsPrimaryNode();
+        const intptr_t primary_pos = primary_node->token_pos();
+        if (primary_node->primary().IsFunction()) {
+          array = LoadClosure(primary_node);
+        } else if (primary_node->primary().IsClass()) {
+          const Class& type_class = Class::Cast(primary_node->primary());
           AbstractType& type = Type::ZoneHandle(
               Type::New(type_class, TypeArguments::Handle(),
-                        primary->token_pos(), Heap::kOld));
+                        primary_pos, Heap::kOld));
           type ^= ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
-          array = new TypeNode(primary->token_pos(), type);
-        } else if (primary->primary().IsTypeParameter()) {
+          array = new TypeNode(primary_pos, type);
+        } else if (primary_node->primary().IsTypeParameter()) {
+          if (current_function().is_static()) {
+            const String& name = String::ZoneHandle(
+                TypeParameter::Cast(primary_node->primary()).name());
+            ErrorMsg(primary_pos,
+                     "cannot access type parameter '%s' from static function",
+                     name.ToCString());
+          }
           if (current_block_->scope->function_level() > 0) {
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
           TypeParameter& type_parameter = TypeParameter::ZoneHandle();
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
-              TypeParameter::Cast(primary->primary()),
+              TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
-          array = new TypeNode(primary->token_pos(), type_parameter);
+          array = new TypeNode(primary_pos, type_parameter);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
       selector =  new LoadIndexedNode(bracket_pos,
                                       array,
                                       index,
                                       Class::ZoneHandle());
     } else if (CurrentToken() == Token::kLPAREN) {
       if (left->IsPrimaryNode()) {
-        PrimaryNode* primary = left->AsPrimaryNode();
-        const intptr_t primary_pos = primary->token_pos();
-        if (primary->primary().IsFunction()) {
-          const Function& func = Function::Cast(primary->primary());
+        PrimaryNode* primary_node = left->AsPrimaryNode();
+        const intptr_t primary_pos = primary_node->token_pos();
+        if (primary_node->primary().IsFunction()) {
+          const Function& func = Function::Cast(primary_node->primary());
           const String& func_name = String::ZoneHandle(func.name());
           if (func.is_static()) {
             // Parse static function call.
             Class& cls = Class::Handle(func.Owner());
             selector = ParseStaticCall(cls, func_name, primary_pos);
           } else {
             // Dynamic function call on implicit "this" parameter.
             if (current_function().is_static()) {
               ErrorMsg(primary_pos,
                        "cannot access instance method '%s' "
                        "from static function",
                        func_name.ToCString());
             }
             selector = ParseInstanceCall(LoadReceiver(primary_pos), func_name);
           }
-        } else if (primary->primary().IsString()) {
+        } else if (primary_node->primary().IsString()) {
           // Primary is an unresolved name.
-          if (primary->IsSuper()) {
-            ErrorMsg(primary->token_pos(), "illegal use of super");
+          if (primary_node->IsSuper()) {
+            ErrorMsg(primary_pos, "illegal use of super");
           }
-          String& name = String::CheckedZoneHandle(primary->primary().raw());
+          String& name = String::CheckedZoneHandle(
+              primary_node->primary().raw());
           if (current_function().is_static()) {
-            selector = ThrowNoSuchMethodError(primary->token_pos(),
+            selector = ThrowNoSuchMethodError(primary_pos,
                                               current_class(),
                                               name,
                                               NULL,  // No arguments.
                                               InvocationMirror::kStatic,
                                               InvocationMirror::kMethod,
                                               NULL);  // No existing function.
           } else {
             // Treat as call to unresolved (instance) method.
-            AstNode* receiver = LoadReceiver(primary->token_pos());
-            selector = ParseInstanceCall(receiver, name);
+            selector = ParseInstanceCall(LoadReceiver(primary_pos), name);
           }
-        } else if (primary->primary().IsTypeParameter()) {
-          // TODO(regis): Issue 13134.  Make sure the error message is the
-          // one we want here and add a test covering this code.
+        } else if (primary_node->primary().IsTypeParameter()) {
           const String& name = String::ZoneHandle(
-              TypeParameter::Cast(primary->primary()).name());
-          selector = ThrowNoSuchMethodError(primary->token_pos(),
-                                            current_class(),
-                                            name,
-                                            NULL,  // No arguments.
-                                            InvocationMirror::kStatic,
-                                            InvocationMirror::kMethod,
-                                            NULL);  // No existing function.
-        } else if (primary->primary().IsClass()) {
-          const Class& type_class = Class::Cast(primary->primary());
+              TypeParameter::Cast(primary_node->primary()).name());
+          if (current_function().is_static()) {
+            // Treat as this.T(), because T is in scope.
+            ErrorMsg(primary_pos,
+                     "cannot access type parameter '%s' from static function",
+                     name.ToCString());
+          } else {
+            // Treat as call to unresolved (instance) method.
+            selector = ParseInstanceCall(LoadReceiver(primary_pos), name);
+          }
+        } else if (primary_node->primary().IsClass()) {
+          const Class& type_class = Class::Cast(primary_node->primary());
           AbstractType& type = Type::ZoneHandle(Type::New(
-              type_class, TypeArguments::Handle(), primary->token_pos()));
+              type_class, TypeArguments::Handle(), primary_pos));
           type ^= ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
-          selector = new TypeNode(primary->token_pos(), type);
+          selector = new TypeNode(primary_pos, type);
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       } else {
         // Left is not a primary node; this must be a closure call.
         AstNode* closure = left;
         selector = ParseClosureCall(closure);
       }
     } else {
       // No (more) selectors to parse.
       left = LoadFieldIfUnresolved(left);
       if (left->IsPrimaryNode()) {
-        PrimaryNode* primary = left->AsPrimaryNode();
-        if (primary->primary().IsFunction()) {
+        PrimaryNode* primary_node = left->AsPrimaryNode();
+        const intptr_t primary_pos = primary->token_pos();
+        if (primary_node->primary().IsFunction()) {
           // Treat as implicit closure.
-          left = LoadClosure(primary);
-        } else if (primary->primary().IsClass()) {
-          const Class& type_class = Class::Cast(primary->primary());
+          left = LoadClosure(primary_node);
+        } else if (primary_node->primary().IsClass()) {
+          const Class& type_class = Class::Cast(primary_node->primary());
           AbstractType& type = Type::ZoneHandle(Type::New(
-              type_class, TypeArguments::Handle(), primary->token_pos()));
+              type_class, TypeArguments::Handle(), primary_pos));
           type = ClassFinalizer::FinalizeType(
               current_class(), type, ClassFinalizer::kCanonicalize);
           // Type may be malbounded, but not malformed.
           ASSERT(!type.IsMalformed());
-          left = new TypeNode(primary->token_pos(), type);
-        } else if (primary->primary().IsTypeParameter()) {
+          left = new TypeNode(primary_pos, type);
+        } else if (primary_node->primary().IsTypeParameter()) {
+          if (current_function().is_static()) {
+            const String& name = String::ZoneHandle(
+                TypeParameter::Cast(primary_node->primary()).name());
+            ErrorMsg(primary_pos,
+                     "cannot access type parameter '%s' from static function",
+                     name.ToCString());
+          }
           if (current_block_->scope->function_level() > 0) {
             // Make sure that the instantiator is captured.
             CaptureInstantiator();
           }
           TypeParameter& type_parameter = TypeParameter::ZoneHandle();
           type_parameter ^= ClassFinalizer::FinalizeType(
               current_class(),
-              TypeParameter::Cast(primary->primary()),
+              TypeParameter::Cast(primary_node->primary()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
-          left = new TypeNode(primary->token_pos(), type_parameter);
-        } else if (primary->IsSuper()) {
+          left = new TypeNode(primary_pos, type_parameter);
+        } else if (primary_node->IsSuper()) {
           // Return "super" to handle unary super operator calls,
           // or to report illegal use of "super" otherwise.
-          left = primary;
+          left = primary_node;
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
       // Done parsing selectors.
       return left;
     }
     ASSERT(selector != NULL);
     left = selector;
   }
@@ skipping 659 matching lines @@
         return new TypeNode(ident_pos, type_parameter);
       }
     }
     // 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);
   }
   if (resolved->IsPrimaryNode()) {
     PrimaryNode* primary = resolved->AsPrimaryNode();
+    const intptr_t primary_pos = primary->token_pos();
     if (primary->primary().IsString()) {
       // We got an unresolved name. If we are compiling a static
       // method, evaluation of an unresolved identifier causes a
       // NoSuchMethodError to be thrown. In an instance method, we convert
       // the unresolved name to an instance field access, since a
       // subclass might define a field with this name.
       if (current_function().is_static()) {
         resolved = ThrowNoSuchMethodError(ident_pos,
                                           current_class(),
                                           ident,
                                           NULL,  // No arguments.
                                           InvocationMirror::kStatic,
                                           InvocationMirror::kField,
                                           NULL);  // No existing function.
       } else {
         // Treat as call to unresolved instance field.
         resolved = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
     } else if (primary->primary().IsFunction()) {
       if (allow_closure_names) {
         resolved = LoadClosure(primary);
       } else {
         ErrorMsg(ident_pos, "illegal reference to method '%s'",
                  ident.ToCString());
       }
     } else if (primary->primary().IsClass()) {
       const Class& type_class = Class::Cast(primary->primary());
       AbstractType& type = Type::ZoneHandle(
-          Type::New(type_class, TypeArguments::Handle(), primary->token_pos()));
+          Type::New(type_class, TypeArguments::Handle(), primary_pos));
       type ^= ClassFinalizer::FinalizeType(
           current_class(), type, ClassFinalizer::kCanonicalize);
       // Type may be malbounded, but not malformed.
       ASSERT(!type.IsMalformed());
-      resolved = new TypeNode(primary->token_pos(), type);
+      resolved = new TypeNode(primary_pos, type);
     }
   }
   return resolved;
 }
 
 
 // Parses type = [ident "."] ident ["<" type { "," type } ">"], then resolve and
 // finalize it according to the given type finalization mode.
 RawAbstractType* Parser::ParseType(
     ClassFinalizer::FinalizationKind finalization) {
@@ skipping 1474 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart