Reapply r27285: "Support dynamic as type literal."

sdk/lib/_internal/compiler/implementation/resolution/members.dart

 // 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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 1733 matching lines @@
       // TODO(karlklose): clean this up (dartbug.com/8870).
       inCheckContext = compiler.enableTypeAssertions &&
           !element.isLibrary() &&
           !element.isTypedef() &&
           !element.enclosingElement.isTypedef(),
       inCatchBlock = false,
       super(compiler, mapping);
 
   ResolutionEnqueuer get world => compiler.enqueuer.resolution;
 
-  Element lookup(Node node, SourceString name) {
-    Element result = scope.lookup(name);
+  Element reportLookupErrorIfAny(Element result, Node node, SourceString name) {
     if (!Elements.isUnresolved(result)) {
       if (!inInstanceContext && result.isInstanceMember()) {
         compiler.reportError(
             node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': name});
         return new ErroneousElementX(MessageKind.NO_INSTANCE_AVAILABLE,
                                      {'name': name},
                                      name, enclosingElement);
       } else if (result.isAmbiguous()) {
         AmbiguousElement ambiguous = result;
         compiler.reportError(
             node, ambiguous.messageKind.error, ambiguous.messageArguments);
         ambiguous.diagnose(enclosingElement, compiler);
         return new ErroneousElementX(ambiguous.messageKind.error,
                                      ambiguous.messageArguments,
                                      name, enclosingElement);
       }
     }
     return result;
   }
 
+  Element lookupAndReport(Node node, SourceString name) {

[ngeoffray, 2013/09/10 08:21:18]

Since this is only called once, I'd prefer inlining it in the caller.

[karlklose, 2013/09/10 11:42:33]

Done.

+    Element result = scope.lookup(name);
+    return reportLookupErrorIfAny(result, node, name);
+  }
+
   // Create, or reuse an already created, statement element for a statement.
   TargetElement getOrCreateTargetElement(Node statement) {
     TargetElement element = mapping[statement];
     if (element == null) {
       element = new TargetElementX(statement,
                                    statementScope.nestingLevel,
                                    enclosingElement);
       mapping[statement] = element;
     }
     return element;
@@ skipping 35 matching lines @@
         error(node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': node});
       }
       return null;
     } else if (node.isSuper()) {
       if (!inInstanceContext) error(node, MessageKind.NO_SUPER_IN_STATIC);
       if ((ElementCategory.SUPER & allowedCategory) == 0) {
         error(node, MessageKind.INVALID_USE_OF_SUPER);
       }
       return null;
     } else {
-      Element element = lookup(node, node.source);
+      SourceString name = node.source;
+      Element element = scope.lookup(name);
+      if (Elements.isUnresolved(element) && name.slowToString() == 'dynamic') {
+        element = compiler.dynamicClass;
+      }
+      element = reportLookupErrorIfAny(element, node, node.source);
       if (element == null) {
         if (!inInstanceContext) {
           element = warnAndCreateErroneousElement(
               node, node.source, MessageKind.CANNOT_RESOLVE,
               {'name': node});
           compiler.backend.registerThrowNoSuchMethod(mapping);
         }
       } else if (element.isErroneous()) {
         // Use the erroneous element.
       } else {
@@ skipping 2279 matching lines @@
         error(node, MessageKind.NOT_A_TYPE.error, {'node': name});
       }
     } else {
       internalError(node.receiver, 'unexpected element $e');
     }
     return e;
   }
 
   Element visitIdentifier(Identifier node) {
     SourceString name = node.source;
-    Element e = resolver.lookup(node, name);
+    Element e = resolver.lookupAndReport(node, name);
     // TODO(johnniwinther): Change errors to warnings, cf. 11.11.1.
     if (e == null) {
       return failOrReturnErroneousElement(resolver.enclosingElement, node, name,
                                           MessageKind.CANNOT_RESOLVE,
                                           {'name': name});
     } else if (e.isErroneous()) {
       return e;
     } else if (identical(e.kind, ElementKind.TYPEDEF)) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF,
             {'typedefName': name});
     } else if (identical(e.kind, ElementKind.TYPE_VARIABLE)) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
             {'typeVariableName': name});
     } else if (!identical(e.kind, ElementKind.CLASS)
         && !identical(e.kind, ElementKind.PREFIX)) {
       error(node, MessageKind.NOT_A_TYPE.error, {'node': name});
     }
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }