Support class and typedef literals as expressions.

lib/compiler/implementation/ssa/builder.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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 1302 matching lines @@
         f: (ClassElement enclosingClass, Element member) {
       constructorArguments.add(
           potentiallyCheckType(fieldValues[member], member));
     });
 
     HForeignNew newObject = new HForeignNew(classElement, constructorArguments);
     add(newObject);
 
     // Create the runtime type information, if needed.
     InterfaceType type = classElement.computeType(compiler);
-      List<HInstruction> inputs = <HInstruction>[];
-      if (compiler.world.needsRti(classElement)) {

[ngeoffray, 2012/10/10 07:32:24]

I don't think you should remove this check.

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

Done.

-      classElement.typeVariables.forEach((TypeVariableType typeVariable) {
-        inputs.add(localsHandler.directLocals[typeVariable.element]);
-      });
-      callSetRuntimeTypeInfo(classElement, inputs, newObject);
-    }
+    List<HInstruction> inputs = <HInstruction>[];
+    classElement.typeVariables.forEach((TypeVariableType typeVariable) {
+      inputs.add(localsHandler.directLocals[typeVariable.element]);
+    });
+    callSetRuntimeTypeInfo(classElement, inputs, newObject);
 
     // Generate calls to the constructor bodies.
     for (int index = constructors.length - 1; index >= 0; index--) {
       FunctionElement constructor = constructors[index];
       assert(invariant(functionElement, constructor.isImplementation));
       ConstructorBodyElement body = getConstructorBody(constructor);
       if (body === null) continue;
       List bodyCallInputs = <HInstruction>[];
       bodyCallInputs.add(newObject);
       FunctionSignature functionSignature = body.computeSignature(compiler);
@@ skipping 1361 matching lines @@
   visitSuperSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (element === null) return generateSuperNoSuchMethodSend(node);
     // TODO(5346): Try to avoid the need for calling [declaration] before
     // creating an [HStatic].
     HInstruction target = new HStatic(element.declaration);
     HInstruction context = localsHandler.readThis();
     add(target);
     var inputs = <HInstruction>[target, context];
-    if (node.isPropertyAccess) {
+    if (node.isPropertyAccessOrTypeReference) {
       push(new HInvokeSuper(inputs));
     } else if (element.isFunction() || element.isGenerativeConstructor()) {
       // TODO(5347): Try to avoid the need for calling [implementation] before
       // calling [addStaticSendArgumentsToList].
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     element.implementation,
                                                     inputs);
       if (!succeeded) {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
@@ skipping 74 matching lines @@
     // Construct the runtime type information.
     StringBuffer runtimeCode = new StringBuffer();
     List<HInstruction> runtimeCodeInputs = <HInstruction>[];
     if (runtimeTypeIsUsed) {
       String runtimeTypeString =
           RuntimeTypeInformation.generateRuntimeTypeString(element,
                                                            rtiInputs.length);
       HInstruction runtimeType = createForeign(runtimeTypeString, rtiInputs);
       add(runtimeType);
       runtimeCodeInputs.add(runtimeType);
-      runtimeCode.add('runtimeType: #');
+      runtimeCode.add("runtimeType: '#'");
     }
     if (needsRti) {
       if (runtimeTypeIsUsed) runtimeCode.add(', ');
       String typeVariablesString =
           RuntimeTypeInformation.generateTypeVariableString(element,
                                                             rtiInputs.length);
       HInstruction typeInfo = createForeign(typeVariablesString, rtiInputs);
       add(typeInfo);
       runtimeCodeInputs.add(typeInfo);
       runtimeCode.add('#');
@@ skipping 52 matching lines @@
       // exception at runtime.
       compiler.cancel('Unimplemented non-matching static call', node: node);
     }
 
     TypeAnnotation annotation = node.getTypeAnnotation();
     if (annotation == null) {
       compiler.internalError("malformed send in new expression");
     }
     InterfaceType type = elements.getType(annotation);
     if (compiler.world.needsRti(constructor.enclosingElement)) {
-      type.arguments.forEach((DartType argument) {
-        inputs.add(analyzeTypeArgument(argument, node));
-      });
+      if (!type.arguments.isEmpty()) {
+        type.arguments.forEach((DartType argument) {
+          inputs.add(analyzeTypeArgument(argument, node));
+        });
+      } else if (compiler.enabledRuntimeType) {
+        Link<DartType> variables =
+            constructor.getEnclosingClass().typeVariables;
+        if (!variables.isEmpty()) {

[ngeoffray, 2012/10/10 07:32:24]

Please add a comment that you need to put runtime names to type variables.

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

Here I add 'dynamic' as type argument for type variables when the type
annotation uses raw syntax. I'll add a comment explaining this.

+          DartString stringDynamic = new DartString.literal('dynamic');
+          HInstruction input = graph.addConstantString(stringDynamic,
+                                                       node,
+                                                       constantSystem);
+          variables.forEach((_) => inputs.add(input));
+        }
+      }
     }
 
     HType elementType = computeType(constructor);
     HInstruction newInstance = new HInvokeStatic(inputs, elementType);
     pushWithPosition(newInstance, node);
 
     // The List constructor forwards to a Dart static method that does
     // not know about the type argument. Therefore we special case
     // this constructor to have the setRuntimeTypeInfo called where
     // the 'new' is done.
@@ skipping 41 matching lines @@
       if (returnType != null) instruction.guaranteedType = returnType;
       pushWithPosition(instruction, node);
     } else {
       generateGetter(node, element);
       List<HInstruction> inputs = <HInstruction>[pop()];
       addDynamicSendArgumentsToList(node, inputs);
       pushWithPosition(new HInvokeClosure(selector, inputs), node);
     }
   }
 
+  visitClassLiteralSend(Send node) {
+    ClassElement element = elements[node];
+    String string =
+          RuntimeTypeInformation.generateRuntimeTypeString(element, 0);
+    DartString className = new DartString.literal(string);
+    Element helper =
+        compiler.findHelper(const SourceString('getOrCreateCachedRuntimeType'));
+    Constant typeName = constantSystem.createString(className, node.selector);
+    pushInvokeHelper1(helper, graph.addConstant(typeName));
+  }
+
   visitGetterSend(Send node) {
     generateGetter(node, elements[node]);
   }
 
   // TODO(antonm): migrate rest of SsaBuilder to internalError.
   internalError(String reason, [Node node]) {
     compiler.internalError(reason, node: node);
   }
 
   void generateRuntimeError(Node node, String message) {
@@ skipping 130 matching lines @@
     } else {
       assert(const SourceString("++") == op.source ||
              const SourceString("--") == op.source ||
              node.assignmentOperator.source.stringValue.endsWith("="));
       Element element = elements[node];
       bool isCompoundAssignment = !node.arguments.isEmpty();
       bool isPrefix = !node.isPostfix;  // Compound assignments are prefix.
 
       // [receiver] is only used if the node is an instance send.
       HInstruction receiver = null;
-      if (Elements.isInstanceSend(node, elements)) {
+      Element selectorElement = elements[node.selector];
+      if (!Elements.isUnresolved(selectorElement)
+          && selectorElement.kind == ElementKind.CLASS) {
+        visitClassLiteralSend(node);

[ngeoffray, 2012/10/10 07:32:24]

What is this about? Object = 42?

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

also for ++ and --.

+      } else if (Elements.isInstanceSend(node, elements)) {
         receiver = generateInstanceSendReceiver(node);
         generateInstanceGetterWithCompiledReceiver(node, receiver);
       } else {
         generateGetter(node, elements[node.selector]);
       }
       HInstruction left = pop();
       HInstruction right;
       if (isCompoundAssignment) {
         visit(node.argumentsNode);
         right = pop();
@@ skipping 1294 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }