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 2932 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.
+          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(Identifier 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.isCall) {
+      // This send is of the form 'e(...)', where e is resolved to a type
+      // reference. We create a regular closure call on the result of the type
+      // reference instead of creating a NoSuchMethodError to avoid pulling it
+      // in if it is not used (e.g., in a try/catch).
+      HInstruction target = pop();
+      Selector selector = elements.getSelector(node);
+      List<HInstruction> inputs = <HInstruction>[target];
+      addDynamicSendArgumentsToList(node, inputs);
+      push(new HInvokeClosure(selector, inputs));
+    }
+  }
+
   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 79 matching lines @@
       // TODO(karlklose): add type representation
       ConstantHandler handler = compiler.constantHandler;
       Constant constant = handler.compileNodeWithDefinitions(node, elements);
       stack.add(graph.addConstant(constant));
     } else {
       visitNewSend(node.send, elements.getType(node));
     }
   }
 
   visitSendSet(SendSet node) {
+    Element element = elements[node];
+    if (!Elements.isUnresolved(element) && element.impliesType()) {
+      Identifier selector = node.selector;
+      generateThrowNoSuchMethod(node, selector.source.slowToString(),
+                                argumentNodes: node.arguments);
+      return;
+    }
     Operator op = node.assignmentOperator;
     if (node.isSuperCall) {
-      Element element = elements[node];
       if (element == null) return generateSuperNoSuchMethodSend(node);
       HInstruction target = new HStatic(element);
       HInstruction context = localsHandler.readThis();
       add(target);
       var inputs = <HInstruction>[target, context];
       addDynamicSendArgumentsToList(node, inputs);
       if (!identical(node.assignmentOperator.source.stringValue, '=')) {
         compiler.unimplemented('complex super assignment',
                                node: node.assignmentOperator);
       }
@@ skipping 57 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;
+      Element selectorElement = elements[node];

[ahe, 2012/11/05 09:47:05]

This is unused.

       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);
@@ skipping 1307 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;
   }
 }