Fix stuff

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 4906 matching lines @@
       no_args);
 
   // Generate assignment of next iterator value to loop variable.
   AstNode* loop_var_assignment = NULL;
   if (loop_var != NULL) {
     // The for loop declares a new variable. Add it to the loop body scope.
     current_block_->scope->AddVariable(loop_var);
     loop_var_assignment =
         new StoreLocalNode(loop_var_pos, *loop_var, iterator_next);
   } else {
-    AstNode* loop_var_primary = ResolveVarOrField(loop_var_pos, *loop_var_name);
+    AstNode* loop_var_primary =
+        ResolveIdent(loop_var_pos, *loop_var_name, false);
     ASSERT(!loop_var_primary->IsPrimaryNode());
     loop_var_assignment =
         CreateAssignmentNode(loop_var_primary, iterator_next);
     if (loop_var_assignment == NULL) {
       ErrorMsg(loop_var_pos, "variable or field '%s' is not assignable",
                loop_var_name->ToCString());
     }
   }
   current_block_->statements->Add(loop_var_assignment);
 
@@ skipping 2287 matching lines @@
     // an error.
     ErrorMsg(qual_ident.ident_pos, "identifier '%s.%s' cannot be resolved",
              String::Handle(qual_ident.lib_prefix->name()).ToCString(),
              qual_ident.ident->ToCString());
   }
   return result;
 }
 
 
 // Resolve identifier, issue an error message if the name refers to
-// a method or a class/interface.
+// a class/interface or a type parameter. Issue an error message if
+// the ident refers to a method and allow_closure_names is false.
 // If the name cannot be resolved, turn it into an instance field access
 // if we're compiling an instance method, or issue an error message
 // if we're compiling a static method.
-AstNode* Parser::ResolveVarOrField(intptr_t ident_pos, const String& ident) {
-  TRACE_PARSER("ResolveVarOrField");
+AstNode* Parser::ResolveIdent(intptr_t ident_pos,
+                              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* var_or_field = NULL;
-  ResolveIdentInLocalScope(ident_pos, ident, &var_or_field);
-  if (var_or_field == NULL) {
+  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()) {
       TypeParameter& type_param = TypeParameter::Handle(
           scope_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).
     QualIdent qual_ident;
     qual_ident.lib_prefix = NULL;
     qual_ident.ident_pos = ident_pos;
     qual_ident.ident = &(String::ZoneHandle(ident.raw()));
-    var_or_field = ResolveIdentInLibraryScope(library_,
+    resolved = ResolveIdentInLibraryScope(library_,
                                               qual_ident,
                                               kResolveIncludingImports);
   }
-  if (var_or_field->IsPrimaryNode()) {
-    PrimaryNode* primary = var_or_field->AsPrimaryNode();
+  if (resolved->IsPrimaryNode()) {
+    PrimaryNode* primary = resolved->AsPrimaryNode();
     if (primary->primary().IsString()) {
       // We got an unresolved name. If we are compiling a static
       // method, this is an error. 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()) {
         ErrorMsg(ident_pos, "identifier '%s' is not declared in this scope",
                  ident.ToCString());
       } else {
         // Treat as call to unresolved instance field.
-        var_or_field = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
+        resolved = CallGetter(ident_pos, LoadReceiver(ident_pos), ident);
       }
     } else if (primary->primary().IsFunction()) {
-      ErrorMsg(ident_pos, "illegal reference to method '%s'",
-               ident.ToCString());
+      if (allow_closure_names) {
+        resolved = LoadClosure(primary);
+      } else {
+        ErrorMsg(ident_pos, "illegal reference to method '%s'",
+                 ident.ToCString());
+      }
     } else {
       ASSERT(primary->primary().IsClass());
       ErrorMsg(ident_pos, "illegal reference to class or interface '%s'",
                ident.ToCString());
     }
   }
-  return var_or_field;
+  return resolved;
 }
 
 
 // Resolve variables used in an import string literal.
 // If the variable name cannot be resolved issue an error message.
 // Currently we only resolve against the global map which is passed in
 // when the script is loaded.
 RawString* Parser::ResolveImportVar(intptr_t ident_pos, const String& ident) {
   TRACE_PARSER("ResolveImportVar");
   const Array& import_map =
@@ skipping 773 matching lines @@
   bool is_compiletime_const = true;
   ArrayNode* values = new ArrayNode(token_index_, TypeArguments::ZoneHandle());
   while (CurrentToken() == Token::kSTRING) {
     values->AddElement(new LiteralNode(token_index_, *CurrentLiteral()));
     ConsumeToken();
     while ((CurrentToken() == Token::kINTERPOL_VAR) ||
         (CurrentToken() == Token::kINTERPOL_START)) {
       AstNode* expr = NULL;
       const intptr_t expr_pos = token_index_;
       if (CurrentToken() == Token::kINTERPOL_VAR) {
-        expr = ResolveVarOrField(token_index_, *CurrentLiteral());
-        ASSERT(!expr->IsPrimaryNode());
+        expr = ResolveIdent(token_index_, *CurrentLiteral(), true);
         ConsumeToken();
       } else {
         ASSERT(CurrentToken() == Token::kINTERPOL_START);
         ConsumeToken();
         expr = ParseExpr(kAllowConst);
         ExpectToken(Token::kINTERPOL_END);
       }
       // Check if this interpolated string is still considered a compile time
       // constant. If it is we need to evaluate if the current string part is
       // a constant or not.
@@ skipping 482 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart