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.
 
 part of ssa;
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
@@ skipping 2909 matching lines @@
 
     // Construct the runtime type information.
     StringBuffer runtimeCode = new StringBuffer();
     List<HInstruction> runtimeCodeInputs = <HInstruction>[];
     if (runtimeTypeIsUsed) {
       String runtimeTypeString =
           rti.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 51 matching lines @@
       generateWrongArgumentCountError(node, constructor, node.arguments);
       return;
     }
 
     if (type.element.modifiers.isAbstract() &&
         constructor.isGenerativeConstructor()) {
       generateAbstractClassInstantiationError(node, type.name.slowToString());
       return;
     }
     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) {
+          // If the class has type variables but no type arguments have been
+          // provided, add [:dynamic:] as argument for all type variables.

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

Can't we find that at runtime instead?

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

We could by wrapping each type variable in a call to a helper method in the
factory. If you prefer that, I can do it, but I do not intend to keep the
current solution for long, so perhaps a TODO here would suffice?

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

What other solution are you thinking of? One that happens at runtime or
compile-time?

+          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 51 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);
     }
   }
 
+  HConstant addConstantString(Send node, String string) {
+    DartString dartString = new DartString.literal(string);
+    Constant constant = constantSystem.createString(dartString, node);
+    return graph.addConstant(constant);
+  }
+
+  visitTypeReferenceSend(Send node) {
+    Element element = elements[node];
+    HInstruction name;
+    Element helper =
+        compiler.findHelper(RuntimeTypeInformation.CACHE_HELPER_NAME);
+    if (element.isClass()) {
+      String string = rti.generateRuntimeTypeString(element, 0);
+      name = addConstantString(node.selector, string);
+    } else if (element.isTypedef()) {
+      // TODO(karlklose): implement support for type variables in typedefs.
+      name = addConstantString(node.selector, rti.getName(element));
+    } else if (element.isTypeVariable()) {
+      // TODO(6248): implement support for type variables.
+      compiler.unimplemented('first class type for type variable', node: node);
+    } else {
+      internalError('unexpected element $element', node: node);
+    }
+    pushInvokeHelper1(helper, name);
+    if (node.isFunctionObjectInvocation) {
+      // This send is of the form 'e(...)', where e is resolved to a type
+      // reference.

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

Please add a comment that you're doing a regular closure call that you know will
throw at runtime, but we don't want to code generate the throw because otherwise
we would drag NoSuchMethod which may not be useful if there are no try/catch.

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

Done.

+      HInstruction target = pop();
+      Selector selector = elements.getSelector(node);
+      selector = new Selector.callClosure(selector.argumentCount,
+                                          selector.namedArguments);
+      List<HInstruction> inputs = <HInstruction>[target];
+      addDynamicSendArgumentsToList(node, inputs);
+      push(new HInvokeDynamicMethod(selector, inputs));

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

Could you use HInvokeDynamicClosure? You should not need to create a selector.

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

Yes, it works!

+    }
+    // Enable the runtime type cache, so that the emitter generates one even
+    // if we do not have [runtimeType] in the program.

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

How can that happen?

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

If we use a class literal, but not the runtimeType getter, we need the cache but
we do not need to enable runtime type information for all objects.

+    compiler.enableRuntimeTypeCache();
+  }
+
   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 generateError(Node node, String message, Element helper) {
-    DartString messageObject = new DartString.literal(message);
-    Constant messageConstant =
-        constantSystem.createString(messageObject, node);
-    HInstruction errorMessage = graph.addConstant(messageConstant);
+    HInstruction errorMessage = addConstantString(node, message);
     pushInvokeHelper1(helper, errorMessage);
   }
 
   void generateRuntimeError(Node node, String message) {
     generateError(node, message, interceptors.getThrowRuntimeError());
   }
 
   void generateAbstractClassInstantiationError(Node node, String message) {
     generateError(node,
                   message,
@@ skipping 159 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];

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

Why is the class on the selector and not the receiver?

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

It is on both, but I changed it to read it from the node.

+      if (!Elements.isUnresolved(selectorElement)
+          && selectorElement.impliesType()) {
+        visitTypeReferenceSend(node);
+      } 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 1306 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;
   }
 }