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 8398 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();
+        const intptr_t primary_pos = primary->token_pos();
         if (primary->primary().IsFunction()) {
           array = LoadClosure(primary);
         } 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(), 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);
+          array = new TypeNode(primary_pos, type);
         } else if (primary->primary().IsTypeParameter()) {
+          if (current_function().is_static()) {
+            const String& name = String::ZoneHandle(
+                TypeParameter::Cast(primary->primary()).name());
+            ErrorMsg(primary_pos,

[hausner, 2014/01/18 00:29:55]

I think you can factor this out. It is an error with all selectors: T.id, T[]
and T(), T

As discussed offline, you are missing the T.id case.

[regis, 2014/01/18 00:48:53]

I added the check for T.id, but I did not factor out the code.

+                     "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()),
               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()) {
@@ skipping 12 matching lines @@
               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()) {
           // Primary is an unresolved name.
           if (primary->IsSuper()) {
-            ErrorMsg(primary->token_pos(), "illegal use of super");
+            ErrorMsg(primary_pos, "illegal use of super");
           }
           String& name = String::CheckedZoneHandle(primary->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.
           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.
+          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->primary().IsClass()) {
           const Class& type_class = Class::Cast(primary->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();
+        const intptr_t primary_pos = primary->token_pos();
         if (primary->primary().IsFunction()) {
           // Treat as implicit closure.
           left = LoadClosure(primary);
         } 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_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);
+          left = new TypeNode(primary_pos, type);
         } else if (primary->primary().IsTypeParameter()) {
+          if (current_function().is_static()) {
+            const String& name = String::ZoneHandle(
+                TypeParameter::Cast(primary->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()),
               ClassFinalizer::kCanonicalize);
           ASSERT(!type_parameter.IsMalformed());
-          left = new TypeNode(primary->token_pos(), type_parameter);
+          left = new TypeNode(primary_pos, type_parameter);
         } else if (primary->IsSuper()) {
           // Return "super" to handle unary super operator calls,
           // or to report illegal use of "super" otherwise.
           left = primary;
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
       // Done parsing selectors.
       return left;
@@ skipping 663 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