Support class and typedef literals as expressions.

lib/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 operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 1158 matching lines @@
   Element enclosingElement;
   final TypeResolver typeResolver;
   bool inInstanceContext;
   bool inCheckContext;
   bool inCatchBlock;
   Scope scope;
   ClassElement currentClass;
   ExpressionStatement currentExpressionStatement;
   bool typeRequired = false;
   StatementScope statementScope;
-  int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION;
+  int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION
+      | ElementCategory.IMPLIES_TYPE;
 
   ResolverVisitor(Compiler compiler, Element element, this.mapping)
     : this.enclosingElement = element,
       // When the element is a field, we are actually resolving its
       // initial value, which should not have access to instance
       // fields.
       inInstanceContext = (element.isInstanceMember() && !element.isField())
           || element.isGenerativeConstructor(),
       this.currentClass = element.isMember() ? element.getEnclosingClass()
                                              : null,
@@ skipping 84 matching lines @@
                                                   [node]);
         }
       } else if (element.isErroneous()) {
         element = warnOnErroneousElement(node, element);
       } else {
         if ((element.kind.category & allowedCategory) == 0) {
           // TODO(ahe): Improve error message. Need UX input.
           error(node, MessageKind.GENERIC, ["is not an expression $element"]);
         }
       }
+      if (!Elements.isUnresolved(element)
+          && element.kind == ElementKind.CLASS) {
+        ClassElement classElement = element;
+        classElement.ensureResolved(compiler);
+      }
       return useElement(node, element);
     }
   }
 
   Element visitTypeAnnotation(TypeAnnotation node) {
     DartType type = resolveTypeAnnotation(node);
     if (type != null) {
       if (inCheckContext) {
         compiler.enqueuer.resolution.registerIsCheck(type);
       }
@@ skipping 205 matching lines @@
           error(node.selector,
                 MessageKind.WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT,
                 [selector.argumentCount]);
         } else if (selector.namedArgumentCount != 0) {
           error(node.selector,
                 MessageKind.ASSERT_IS_GIVEN_NAMED_ARGUMENTS,
                 [selector.namedArgumentCount]);
         }
         return compiler.assertMethod;
       }
+
       return node.selector.accept(this);
     }
 
     var oldCategory = allowedCategory;
-    allowedCategory |=
-      ElementCategory.CLASS | ElementCategory.PREFIX | ElementCategory.SUPER;
+    allowedCategory |= ElementCategory.PREFIX | ElementCategory.SUPER;
     Element resolvedReceiver = visit(node.receiver);
     allowedCategory = oldCategory;
 
     Element target;
     SourceString name = node.selector.asIdentifier().source;
     if (identical(name.stringValue, 'this')) {
       error(node.selector, MessageKind.GENERIC, ["expected an identifier"]);
     } else if (node.isSuperCall) {
       if (node.isOperator) {
         if (isUserDefinableOperator(name.stringValue)) {
@@ skipping 14 matching lines @@
       // TODO(johnniwinther): Ensure correct behavior if currentClass is a
       // patch.
       target = currentClass.lookupSuperMember(name);
       // [target] may be null which means invoking noSuchMethod on
       // super.
     } else if (Elements.isUnresolved(resolvedReceiver)) {
       return null;
     } else if (identical(resolvedReceiver.kind, ElementKind.CLASS)) {
       ClassElement receiverClass = resolvedReceiver;
       receiverClass.ensureResolved(compiler);
+      if (node.isOperator) {
+        // When the resolved receiver is a class, we can have two cases:
+        //  1) a static send: C.foo, or
+        //  2) an operator send, where the receiver is a class literal: 'C + 1'.
+        // The following code that looks up the selector on the resolved
+        // receiver will treat the second as the invocation of a static operator
+        // if the resolved receiver is not null.
+        return null;
+      }
       target = receiverClass.lookupLocalMember(name);
       if (target == null) {
         // TODO(johnniwinther): With the simplified [TreeElements] invariant,
         // try to resolve injected elements if [currentClass] is in the patch
         // library of [receiverClass].
 
         // TODO(karlklose): this should be reported by the caller of
         // [resolveSend] to select better warning messages for getters and
         // setters.
         return warnAndCreateErroneousElement(node, name,
                                              MessageKind.METHOD_NOT_FOUND,
                                              [receiverClass.name, name]);
       } else if (target.isInstanceMember()) {
         error(node, MessageKind.MEMBER_NOT_STATIC, [receiverClass.name, name]);
       }
     } else if (identical(resolvedReceiver.kind, ElementKind.PREFIX)) {
       PrefixElement prefix = resolvedReceiver;
       target = prefix.lookupLocalMember(name);
-      if (target == null) {
+      if (Elements.isUnresolved(target)) {
         return warnAndCreateErroneousElement(
             node, name, MessageKind.NO_SUCH_LIBRARY_MEMBER,
             [prefix.name, name]);
+      } else if (target.kind == ElementKind.CLASS) {
+        ClassElement classElement = target;
+        classElement.ensureResolved(compiler);
       }
     }
     return target;
   }
 
   DartType resolveTypeTest(Node argument) {
     TypeAnnotation node = argument.asTypeAnnotation();
     if (node == null) {
       // node is of the form !Type.
       node = argument.asSend().receiver.asTypeAnnotation();
@@ skipping 119 matching lines @@
 
     if (node.isCall) {
       if (Elements.isUnresolved(target) ||
           target.isGetter() ||
           Elements.isClosureSend(node, target)) {
         // If we don't know what we're calling or if we are calling a getter,
         // we need to register that fact that we may be calling a closure
         // with the same arguments.
         Selector call = new Selector.callClosureFrom(selector);
         world.registerDynamicInvocation(call.name, call);
+      } else if (target.impliesType()) {
+        // We call 'call()' on a Type instance returned from the reference to a
+        // class or typedef literal. We do not need to register this call as a
+        // dynamic invocation, because we statically know what the target is.
       } else if (!selector.applies(target, compiler)) {
         warnArgumentMismatch(node, target);
       }
     }
 
     // TODO(ngeoffray): Warn if target is null and the send is
     // unqualified.
     useElement(node, target);
     registerSend(selector, target);
     return node.isPropertyAccess ? target : null;
@@ skipping 1270 matching lines @@
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF, [name]);
     } else if (identical(e.kind, ElementKind.TYPE_VARIABLE)) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE, [name]);
     } else if (!identical(e.kind, ElementKind.CLASS)
         && !identical(e.kind, ElementKind.PREFIX)) {
       error(node, MessageKind.NOT_A_TYPE, [name]);
     }
     return e;
   }
 }