Support class and typedef literals as expressions.

lib/compiler/implementation/resolver.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.
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 1395 matching lines @@
     return scope.lexicalLookup(const SourceString("assert")) !== null;
   }
 
   /** Check if [node] is the expression of the current expression statement. */
   bool isExpressionStatementExpression(Node node) {
     return currentExpressionStatement !== null &&
         currentExpressionStatement.expression === node;
   }
 
   Element resolveSend(Send node) {
+    void withAdditionalCategories(int categories, void f()) {
+      var oldCategory = allowedCategory;
+      allowedCategory |= categories;
+      f();
+      allowedCategory = oldCategory;
+    }
+
     Selector selector = resolveSelector(node);
-
     if (node.receiver === null) {
-      // If this send is the expression of an expression statement, and is on
+      // If this send is the expression of an expression statement, and is of
       // the form "assert(expr);", and there is no declaration with name
       // "assert" in the lexical scope, then this is actually an assertion.
       if (isExpressionStatementExpression(node) &&
           selector.isAssertSyntax() &&
           !isAssertInLexicalScope()) {
         return compiler.assertMethod;
       }
-      return node.selector.accept(this);
+
+      Element result;
+      withAdditionalCategories(ElementCategory.CLASS, () {
+        result = node.selector.accept(this);
+      });
+      return result;
     }
 
-    var oldCategory = allowedCategory;
-    allowedCategory |=
-      ElementCategory.CLASS | ElementCategory.PREFIX | ElementCategory.SUPER;
-    Element resolvedReceiver = visit(node.receiver);
-    allowedCategory = oldCategory;
+    Element resolvedReceiver;
+    withAdditionalCategories(
+        ElementCategory.CLASS | ElementCategory.PREFIX | ElementCategory.SUPER,
+        () { resolvedReceiver = visit(node.receiver); });
+
+    if (resolvedReceiver != null && node.isOperator

[ahe, 2012/10/08 09:09:36]

I don't understand why it is important to test for node.isOperator here?

[karlklose, 2012/10/23 10:33:52]

For class literals that are targets for operators, we resolve the target class
element and ensure the element is resolved (because we need it resolved for
runtime type information).
But we do not associate the Send with the class element, because that would be
interpreted as a call to a static operator on the class. Since there are no
static operators, we should interpret it as a call of the operator on the Type
instance.

+        && resolvedReceiver.kind == ElementKind.CLASS) {
+      // In operator expressions like 'Class + 1', the operator call goes the
+      // instance of [Type] that is the result of the expression 'Class'.
+      ClassElement classElement = resolvedReceiver;
+      resolvedReceiver = null;
+      // We still have to make sure that the class is resolved, because we need
+      // to build its runtime type representation.
+      classElement.ensureResolved(compiler);
+    }
 
     Element target;
     SourceString name = node.selector.asIdentifier().source;
     if (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 {
@@ skipping 70 matching lines @@
           string === '===' || string === '!==' ||
           string === '>>>') {
         return null;
       }
       return node.arguments.isEmpty()
           ? new Selector.unaryOperator(source)
           : new Selector.binaryOperator(source);
     }
 
     Identifier identifier = node.selector.asIdentifier();
-    if (node.isPropertyAccess) {
+    if (node.isPropertyAccessOrTypeReference) {
       assert(!isSet);
       return new Selector.getter(identifier.source, library);
     } else if (isSet) {
       return new Selector.setter(identifier.source, library);
     }
 
     // Compute the arity and the list of named arguments.
     int arity = 0;
     List<SourceString> named = <SourceString>[];
     for (Link<Node> link = node.argumentsNode.nodes;
@@ skipping 29 matching lines @@
       if (argument.asNamedArgument() != null) {
         seenNamedArgument = true;
       } else if (seenNamedArgument) {
         error(argument, MessageKind.INVALID_ARGUMENT_AFTER_NAMED);
       }
     }
   }
 
   visitSend(Send node) {
     Element target = resolveSend(node);
-    if (!Elements.isUnresolved(target)
-        && target.kind == ElementKind.ABSTRACT_FIELD) {
-      AbstractFieldElement field = target;
-      target = field.getter;
-      if (target == null && !inInstanceContext) {
-        target =
-            warnAndCreateErroneousElement(node.selector, field.name,
-                                          MessageKind.CANNOT_RESOLVE_GETTER,
-                                          [node.selector]);
+
+    if (!Elements.isUnresolved(target)) {
+      if (target.kind == ElementKind.ABSTRACT_FIELD) {
+        AbstractFieldElement field = target;
+        target = field.getter;
+        if (target == null && !inInstanceContext) {
+          target =
+              warnAndCreateErroneousElement(node.selector, field.name,
+                                            MessageKind.CANNOT_RESOLVE_GETTER,
+                                            [node.selector]);
+        }
+      } else if (target.kind == ElementKind.CLASS) {
+        ClassElement classElement = target;
+        classElement.ensureResolved(compiler);

[ahe, 2012/10/08 09:09:36]

Why is this not done in resolveSend?

[karlklose, 2012/10/23 10:33:52]

Moved.

       }
     }
 
     bool resolvedArguments = false;
     if (node.isOperator) {
       String operatorString = node.selector.asOperator().source.stringValue;
       if (operatorString === 'is' || operatorString === 'as') {
         assert(node.arguments.tail.isEmpty());
         DartType type = resolveTypeTest(node.arguments.head);
         if (type != null) {
@@ skipping 27 matching lines @@
          target.isGetter() ||
          Elements.isClosureSend(node, target))) {
       Selector call = new Selector.callClosureFrom(selector);
       world.registerDynamicInvocation(call.name, call);
     }
 
     // TODO(ngeoffray): Warn if target is null and the send is
     // unqualified.
     useElement(node, target);
     registerSend(selector, target);
-    return node.isPropertyAccess ? target : null;
+    return node.isPropertyAccessOrTypeReference ? target : null;
   }
 
   visitSendSet(SendSet node) {
     Element target = resolveSend(node);
+    if (!Elements.isUnresolved(target) && target.kind == ElementKind.CLASS) {
+      ClassElement classElement = target;
+      classElement.ensureResolved(compiler);

[ahe, 2012/10/08 09:09:36]

Why is this not done in resolveSend?

[karlklose, 2012/10/23 10:33:52]

Done.

+    }
     Element setter = target;
     Element getter = target;
     SourceString operatorName = node.assignmentOperator.source;
     String source = operatorName.stringValue;
     bool isComplex = source !== '=';
     if (!Elements.isUnresolved(target)
         && target.kind == ElementKind.ABSTRACT_FIELD) {
       AbstractFieldElement field = target;
       setter = field.setter;
       getter = field.getter;
@@ skipping 1491 matching lines @@
     return result;
   }
   Element lookup(SourceString name) => localLookup(name);
   Element lexicalLookup(SourceString name) => localLookup(name);
 
   Element add(Element newElement) {
     throw "Cannot add an element in a patch library scope";
   }
   String toString() => 'PatchLibraryScope($origin,$patch)';
 }