Fix handling of type literals.

sdk/lib/_internal/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;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to implement [TypedElement.type] because our
  * optimizers may look at its declared type.
@@ skipping 4298 matching lines @@
           node);
     }
   }
 
   HConstant addConstantString(String string) {
     ast.DartString dartString = new ast.DartString.literal(string);
     Constant constant = constantSystem.createString(dartString);
     return graph.addConstant(constant, compiler);
   }
 
-  visitTypeReferenceSend(ast.Send node) {
-    Element element = elements[node];
-    if (element.isClass || element.isTypedef) {
+  visitTypePrefixSend(ast.Send node) {
+    compiler.internalError(node, "visitTypePrefixSend should not be called.");
+  }
+
+  visitTypeLiteralSend(ast.Send node) {
+    DartType type = elements.getTypeLiteralType(node);
+    if (type.isInterfaceType || type.isTypedef || type.isDynamic) {
       // TODO(karlklose): add type representation
       if (node.isCall) {
         // The node itself is not a constant but we register the selector (the
         // identifier that refers to the class/typedef) as a constant.
         stack.add(addConstant(node.selector));
       } else {
         stack.add(addConstant(node));
       }
-    } else if (element.isTypeVariable) {
-      TypeVariableElement typeVariable = element;
-      DartType type = localsHandler.substInContext(typeVariable.type);
+    } else if (type.isTypeVariable) {
+      type = localsHandler.substInContext(type);
       HInstruction value = analyzeTypeArgument(type);
       pushInvokeStatic(node,
                        backend.getRuntimeTypeToString(),
                        [value],
                        backend.stringType);
       pushInvokeStatic(node,
                        backend.getCreateRuntimeType(),
                        [pop()]);
     } else {
-      internalError('unexpected element kind $element', node: node);
+      internalError('unexpected type kind ${type.kind}', node: node);
     }
     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);
@@ skipping 2033 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls)));
   }
 }