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 309 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);
+
+      Element result = node.selector.accept(this);
+      if (result != null) {
+        if (result.kind == ElementKind.CLASS) {
+          ClassElement classElement = result;
+          classElement.ensureResolved(compiler);
+        }
+      }
+      return result;
     }
 
     var oldCategory = allowedCategory;
-    allowedCategory |=
-      ElementCategory.CLASS | ElementCategory.PREFIX | ElementCategory.SUPER;
+    allowedCategory |= ElementCategory.PREFIX | ElementCategory.SUPER;
     Element resolvedReceiver = visit(node.receiver);
     allowedCategory = oldCategory;
 
+    if (resolvedReceiver != null
+        && resolvedReceiver.kind == ElementKind.CLASS) {
+      ClassElement classElement = resolvedReceiver;
+      classElement.ensureResolved(compiler);
+      if (node.isOperator) {
+        // In operator expressions like 'Class + 1', the operator call goes the
+        // instance of [Type] that is the result of the expression 'Class'.

[ngeoffray, 2012/10/31 10:33:03]

The comment is not helping me understand what's happening, please be more
verbose and compare it with non-operator calls (where we resolve to a static
method on the class).

[karlklose, 2012/10/31 13:01:18]

Rephrased. Is it better to understand now?

+        resolvedReceiver = null;
+      }
+    }
+
     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)) {
           name = selector.name;
         } else {
           error(node.selector, MessageKind.ILLEGAL_SUPER_SEND, [name]);
@@ skipping 35 matching lines @@
       }
     } else if (identical(resolvedReceiver.kind, ElementKind.PREFIX)) {
       PrefixElement prefix = resolvedReceiver;
       target = prefix.lookupLocalMember(name);
       if (target == null) {
         return warnAndCreateErroneousElement(
             node, name, MessageKind.NO_SUCH_LIBRARY_MEMBER,
             [prefix.name, name]);
       }
     }
+    if (target != null && target.kind == ElementKind.CLASS) {

[ngeoffray, 2012/10/31 10:33:03]

Should that check be in the prefix check?

[karlklose, 2012/10/31 13:01:18]

Where exactly do you mean this should be?

[ngeoffray, 2012/10/31 14:32:43]

line 1590

[karlklose, 2012/10/31 16:32:17]

Yes, makes sense.

+      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();
       if (node == null) compiler.cancel("malformed send");
     }
@@ skipping 117 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 (!selector.applies(target, compiler)) {
+      } else if (target is FunctionElement

[ngeoffray, 2012/10/31 10:33:03]

target.isFunction() ? Or have selector.applies do the filtering?

[karlklose, 2012/10/31 13:01:18]

I added a case for targets that imply a type.

+                 && !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 1269 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;
   }
 }