Handle unresolved identifiers with an accessor.

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

 // Copyright (c) 2016, 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.
 
 library fasta.body_builder;
 
 import '../fasta_codes.dart'
     show FastaMessage, codeExpectedButGot, codeExpectedFunctionBody;
 
 import '../parser/parser.dart' show FormalParameterType, optional;
@@ skipping 127 matching lines @@
   Expression popForValue() => toValue(pop());
 
   Expression popForEffect() => toEffect(pop());
 
   Expression popForValueIfNotNull(Object value) {
     return value == null ? null : popForValue();
   }
 
   @override
   Expression toValue(Object node) {
-    if (node is UnresolvedIdentifier) {
-      if (isDartLibrary &&
-          node.name.name == "main" &&
-          library.uri.path == "_builtin" &&
-          member?.name == "_getMainClosure") {
-        // TODO(ahe): https://github.com/dart-lang/sdk/issues/28989
-        return new NullLiteral()..fileOffset = node.fileOffset;
-      }
-      return throwNoSuchMethodError(
-          node.name.name, new Arguments.empty(), node.fileOffset,
-          isGetter: true);
-    } else if (node is FastaAccessor) {
+    if (node is FastaAccessor) {
       return node.buildSimpleRead();
     } else if (node is TypeVariableBuilder) {
       TypeParameterType type = node.buildTypesWithBuiltArguments(library, null);
       if (!isInstanceContext && type.parameter.parent is Class) {
         return buildCompileTimeError(
             "Type variables can only be used in instance methods.");
       } else {
         if (constantExpressionRequired) {
           addCompileTimeError(-1,
               "Type variable can't be used as a constant expression $type.");
@@ skipping 354 matching lines @@
       return receiver is StaticAccessor &&
           receiver.readTarget ==
               coreTypes.tryGetTopLevelMember("dart:core", null, "identical");
     }
 
     if (receiver is FastaAccessor) {
       if (constantExpressionRequired && !isIdentical(receiver)) {
         addCompileTimeError(charOffset, "Not a constant expression.");
       }
       return receiver.doInvocation(charOffset, arguments);
-    } else if (receiver is UnresolvedIdentifier) {
-      return throwNoSuchMethodError(
-          receiver.name.name, arguments, receiver.fileOffset);
     } else {
       return buildMethodInvocation(
           toValue(receiver), callName, arguments, charOffset);
     }
   }
 
   @override
   void beginCascade(Token token) {
     debugEvent("beginCascade");
     Expression expression = popForValue();
@@ skipping 207 matching lines @@
   builderToFirstExpression(Builder builder, String name, int charOffset,
       {bool isPrefix: false}) {
     if (builder == null || (!isInstanceContext && builder.isInstanceMember)) {
       Name n = new Name(name, library.library);
       if (!isPrefix && isInstanceContext) {
         assert(builder == null);
         if (constantExpressionRequired) {
           addCompileTimeError(charOffset, "Not a constant expression.");
         }
         return new ThisPropertyAccessor(this, charOffset, n, null, null);
+      } else if (isDartLibrary &&
+          name == "main" &&
+          library.uri.path == "_builtin" &&
+          member?.name == "_getMainClosure") {
+        // TODO(ahe): https://github.com/dart-lang/sdk/issues/28989
+        return new NullLiteral()..fileOffset = charOffset;
       } else {
-        if (constantExpressionRequired) {
-          addCompileTimeError(charOffset, "Not a constant expression.");
-        }
-        return new UnresolvedIdentifier(n)..fileOffset = charOffset;
+        return new UnresolvedAccessor(this, n, charOffset);
       }
     } else if (builder.isTypeDeclaration) {
       if (constantExpressionRequired && builder.isTypeVariable) {
         addCompileTimeError(charOffset, "Not a constant expression.");
       }
       return builder;
     } else if (builder.isLocal) {
       if (constantExpressionRequired && !builder.isConst) {
         addCompileTimeError(charOffset, "Not a constant expression.");
       }
@@ skipping 519 matching lines @@
             "Can't be used as a type: '${debugName(prefix, suffix)}'.");
         return;
       }
     }
     if (name is Identifier) {
       name = name.name;
     }
     if (name is FastaAccessor) {
       warning("'${beginToken.lexeme}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
-    } else if (name is UnresolvedIdentifier) {
-      warning("'${name.name}' isn't a type.", beginToken.charOffset);
-      push(const DynamicType());
     } else if (name is TypeVariableBuilder) {
       if (constantExpressionRequired) {
         addCompileTimeError(
             beginToken.charOffset, "Not a constant expression.");
       }
       push(name.buildTypesWithBuiltArguments(library, arguments));
     } else if (name is TypeDeclarationBuilder) {
       push(name.buildTypesWithBuiltArguments(library, arguments));
     } else if (name is TypeBuilder) {
       push(name.build(library));
@@ skipping 1130 matching lines @@
     return expression;
   }
 
   @override
   void debugEvent(String name) {
     // printEvent(name);
   }
 }
 
 // TODO(ahe): Shouldn't need to be an expression.
-class UnresolvedIdentifier extends InvalidExpression {
-  final Name name;
-
-  UnresolvedIdentifier(this.name);
-
-  String toString() => "unresolved-identifier($name)";
-}
-
-// TODO(ahe): Shouldn't need to be an expression.
 class Identifier extends InvalidExpression {
   final String name;
 
   Identifier(this.name);
 
   Expression get initializer => null;
 
   String toString() => "identifier($name)";
 }
 
@@ skipping 430 matching lines @@
 }
 
 String debugName(String className, String name, [String prefix]) {
   String result = name.isEmpty ? className : "$className.$name";
   return prefix == null ? result : "$prefix.result";
 }
 
 String getNodeName(Object node) {
   if (node is Identifier) {
     return node.name;
-  } else if (node is UnresolvedIdentifier) {
-    return node.name.name;
   } else if (node is TypeDeclarationBuilder) {
     return node.name;
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is FastaAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }