Fix handling of unresolved names

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 6025 matching lines @@
                                       field_name);
       }
     } else {
       return GenerateStaticFieldLookup(field, token_index_);
     }
   }
   return access;
 }
 
 
+AstNode* Parser::LoadFieldIfUnresolved(AstNode* node) {
+  if (!node->IsPrimaryNode()) {
+    return node;
+  }
+  PrimaryNode* primary = node->AsPrimaryNode();
+  if (primary->primary().IsString()) {
+    // In a static method, an unresolved identifier is an error.
+    // In an instance method, we convert this into a getter call
+    // for a field (which may be defined in a subclass.)
+    String& name = String::CheckedZoneHandle(primary->primary().raw());
+    if (current_function().is_static() ||
+        current_function().IsInFactoryScope()) {
+      ErrorMsg(primary->token_index(),
+               "identifier '%s' is not declared in this scope",
+               name.ToCString());
+    } else {
+      AstNode* receiver = LoadReceiver(primary->token_index());
+      return CallGetter(node->token_index(), receiver, name);
+    }
+  }
+  return primary;
+}
+
+
+AstNode* Parser::LoadClosure(PrimaryNode* primary) {
+  ASSERT(primary->primary().IsFunction());
+  AstNode* closure = NULL;
+  const Function& func =
+      Function::CheckedZoneHandle(primary->primary().raw());
+  const String& funcname = String::ZoneHandle(func.name());
+  if (func.is_static()) {
+    // Static function access.
+    closure = CreateImplicitClosureNode(func, primary->token_index(), NULL);
+  } else {
+    // Instance function access.
+    if (current_function().is_static() ||
+        current_function().IsInFactoryScope()) {
+      ErrorMsg(primary->token_index(),
+               "cannot access instance method '%s' from static method",
+               funcname.ToCString());
+    }
+    AstNode* receiver = LoadReceiver(primary->token_index());
+    closure = CallGetter(primary->token_index(), receiver, funcname);
+  }
+  return closure;
+}
+
+
 AstNode* Parser::ParsePostfixExpr() {
   TRACE_PARSER("ParsePostfixExpr");
   const intptr_t postfix_expr_pos = token_index_;
   AstNode* postfix_expr = ParsePrimary();
   while (true) {
     AstNode* selector = NULL;
     AstNode* left = postfix_expr;
+    if (left->IsPrimaryNode() &&
+        left->AsPrimaryNode()->primary().IsTypeParameter()) {
+      TypeParameter& type_param =
+          TypeParameter::CheckedHandle(left->AsPrimaryNode()->primary().raw());
+      ASSERT(!type_param.IsNull());
+      String& type_param_name = String::Handle(type_param.Name());
+      ErrorMsg(left->token_index(),
+               "illegal use of type parameter %s",
+               type_param_name.ToCString());
+    }
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
+      if (left->IsPrimaryNode()) {
+        if (left->AsPrimaryNode()->primary().IsFunction()) {
+          left = LoadClosure(left->AsPrimaryNode());
+        } else {
+          left = LoadFieldIfUnresolved(left);
+        }
+      }
       const intptr_t ident_pos = token_index_;
       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.
           Class& cls = Class::CheckedHandle(
               left->AsPrimaryNode()->primary().raw());
           selector = ParseStaticCall(cls, *ident, ident_pos);
@@ skipping 15 matching lines @@
           // Instance field access.
           selector = ParseInstanceFieldAccess(left, *ident);
         } else {
           // Static field access.
           selector = ParseStaticFieldAccess(cls, *ident, ident_pos);
         }
       }
     } else if (CurrentToken() == Token::kLBRACK) {
       const intptr_t bracket_pos = token_index_;
       ConsumeToken();
+      left = LoadFieldIfUnresolved(left);
       const bool saved_mode = SetAllowFunctionLiterals(true);
       AstNode* index = ParseExpr(kAllowConst);
       SetAllowFunctionLiterals(saved_mode);
       ExpectToken(Token::kRBRACK);
       AstNode* array = left;
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary = left->AsPrimaryNode();
         if (primary->primary().IsFunction()) {
-          ErrorMsg(bracket_pos, "cannot apply index operator to function");
+          array = LoadClosure(primary);
         } else if (primary->primary().IsClass()) {
           ErrorMsg(bracket_pos, "cannot apply index operator to class");
-        } else if (primary->primary().IsString()) {
-          // Primary is an unresolved name.
-          String& name = String::CheckedZoneHandle(primary->primary().raw());
-          if (current_function().is_static()) {
-            ErrorMsg(primary->token_index(),
-                     "identifier '%s' is not declared in this scope",
-                     name.ToCString());
-          } else {
-            // Treat as call to unresolved (instance) method.
-            AstNode* receiver = LoadReceiver(primary->token_index());
-            selector = ParseInstanceCall(receiver, name);
-          }
         } else {
-          // Internal parser error.
-          UNREACHABLE();
+          UNREACHABLE();  // Internal parser error.
         }
       }
       selector = new LoadIndexedNode(bracket_pos, array, index);
     } else if (CurrentToken() == Token::kLPAREN) {
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary = left->AsPrimaryNode();
         const intptr_t primary_pos = primary->token_index();
         if (primary->primary().IsFunction()) {
           Function& func = Function::CheckedHandle(primary->primary().raw());
           String& func_name = String::ZoneHandle(func.name());
@@ skipping 20 matching lines @@
                      name.ToCString());
           } else {
             // Treat as call to unresolved (instance) method.
             AstNode* receiver = LoadReceiver(primary->token_index());
             selector = ParseInstanceCall(receiver, name);
           }
         } else if (primary->primary().IsClass()) {
           ErrorMsg(left->token_index(),
                    "must use 'new' or 'const' to construct new instance");
         } else {
-          // Internal parser error.
-          UNREACHABLE();
+          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) selector to parse.
+      left = LoadFieldIfUnresolved(left);
       if (left->IsPrimaryNode()) {
-        if (left->AsPrimaryNode()->primary().IsString()) {
-          PrimaryNode* primary = left->AsPrimaryNode();
-          const String& ident =
-              String::CheckedZoneHandle(primary->primary().raw());
-          // An unresolved identifier that is not followed by a selector token
-          // . or [ or (.
-          // If we are in a static method, this is an error.
-          // If we are compiling an instance method, convert this into
-          // a runtime lookup for a field (which may be defined in a
-          // subclass.)
-          if (current_function().is_static()) {
-            ErrorMsg(primary->token_index(),
-                     "identifier '%s' is not declared in this scope",
-                     ident.ToCString());
-          } else {
-            // Treat as call to unresolved (instance) field.
-            AstNode* receiver = LoadReceiver(primary->token_index());
-            postfix_expr = ParseInstanceFieldAccess(receiver, ident);
-          }
-        } else if (left->AsPrimaryNode()->primary().IsFunction()) {
+        PrimaryNode* primary = left->AsPrimaryNode();
+        if (primary->primary().IsFunction()) {
           // Treat as implicit closure.
-          PrimaryNode* primary = left->AsPrimaryNode();
-          const Function& func =
-              Function::CheckedZoneHandle(primary->primary().raw());
-          const String& funcname = String::ZoneHandle(func.name());
-          if (func.is_static()) {
-            // Static function access.
-            postfix_expr = CreateImplicitClosureNode(func,
-                                                     primary->token_index(),
-                                                     NULL);
-          } else {
-            // Instance function access.
-            if (current_function().is_static() ||
-                current_function().IsInFactoryScope()) {
-              ErrorMsg(primary->token_index(),
-                       "illegal use of method '%s'",
-                       funcname.ToCString());
-            }
-            AstNode* receiver = LoadReceiver(primary->token_index());
-            postfix_expr = ParseInstanceFieldAccess(receiver, funcname);
-          }
+          left = LoadClosure(primary);
+        } else if (left->AsPrimaryNode()->primary().IsClass()) {
+          Class& cls = Class::CheckedHandle(
+              left->AsPrimaryNode()->primary().raw());
+          String& cls_name = String::Handle(cls.Name());
+          ErrorMsg(left->token_index(),
+                   "illegal use of class name '%s'",
+                   cls_name.ToCString());
+        } else {
+          UNREACHABLE();  // Internal parser error.
         }
       }
+      postfix_expr = left;
       // Done parsing selectors.
       break;
     }
     ASSERT(selector != NULL);
     postfix_expr = selector;
   }
   if (IsIncrementOperator(CurrentToken())) {
     TRACE_PARSER("IncrementOperator");
     Token::Kind incr_op = CurrentToken();
     if (!IsAssignableExpr(postfix_expr)) {
@@ skipping 1269 matching lines @@
     OpenBlock();
     primary = ParseFunctionStatement(true);
     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)) {
-        // This is a non-local unqualified identifier so resolve the identifier
-        // locally in the main app library and all libraries imported by it.
-        primary = ResolveIdentInLibraryScope(library_,
-                                             qual_ident,
-                                             kResolveIncludingImports);
+        // Check whether the identifier is a type parameter.
+        const Class& scope_class = Class::Handle(TypeParametersScopeClass());
+        if (!scope_class.IsNull()) {
+          TypeParameter& type_param = TypeParameter::ZoneHandle();
+          type_param = scope_class.LookupTypeParameter(
+                                       *(qual_ident.ident), token_index_);

[regis, 2012/02/23 19:11:44]

Strange indentation.
But why not just one statement:
const TypeParameter& type_param =
TypeParameter::ZoneHandle(scope_class.LookupTypeParameter(...

[hausner, 2012/02/23 19:43:18]

Found it more readable with two statements due to the long expression. Changed
to one statement.

+          if (!type_param.IsNull()) {
+            primary = new PrimaryNode(qual_ident.ident_pos, type_param);
+          }
+        }
+        if (primary == NULL) {
+          // This is a non-local unqualified identifier so resolve the
+          // identifier locally in the main app library and all libraries
+          // imported by it.
+          primary = ResolveIdentInLibraryScope(library_,
+                                               qual_ident,
+                                               kResolveIncludingImports);
+        }
       }
     } else {
       // This is a qualified identifier with a library prefix so resolve
       // the identifier locally in that library (we do not include the
       // libraries imported by that library).
       primary = ResolveIdentInLibraryPrefixScope(*(qual_ident.lib_prefix),
                                                  qual_ident);
     }
     ASSERT(primary != NULL);
   } else if (CurrentToken() == Token::kTHIS) {
@@ skipping 364 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart