Simplify runtime type support.

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;
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
@@ skipping 2504 matching lines @@
       bool isNot = false;
       // TODO(ngeoffray): Duplicating pattern in resolver. We should
       // add a new kind of node.
       if (typeAnnotation == null) {
         typeAnnotation = argument.asSend().receiver;
         isNot = true;
       }
 
       DartType type = elements.getType(typeAnnotation);
       HInstruction typeInfo = null;
-      if (compiler.codegenWorld.rti.hasTypeArguments(type)) {
+      if (RuntimeTypeInformation.hasTypeArguments(type)) {
         pushInvokeHelper1(interceptors.getGetRuntimeTypeInfo(), expression);
         typeInfo = pop();
       }
       if (type.element.isTypeVariable()) {
         // TODO(karlklose): We currently answer true to any is check
         // involving a type variable -- both is T and is !T -- until
         // we have a proper implementation of reified generics.
         stack.add(graph.addConstantBool(true, constantSystem));
       } else {
         HInstruction instruction;
@@ skipping 449 matching lines @@
         // The type variable is stored in a parameter of the factory.
         inputs.add(localsHandler.readLocal(type.element));
       } else if (member.isInstanceMember()
                  || member.isGenerativeConstructor()) {
         // The type variable is stored in [this].
         if (typeInfo == null) {
           pushInvokeHelper1(interceptors.getGetRuntimeTypeInfo(),
                             localsHandler.readThis());
           typeInfo = pop();
         }
+        int index = RuntimeTypeInformation.getTypeVariableIndex(type);
         HInstruction foreign = new HForeign(
-            new LiteralDartString('#.${type.name.slowToString()}'),
+            new LiteralDartString('#[$index]'),
             new LiteralDartString('String'),
             <HInstruction>[typeInfo]);
         add(foreign);
         inputs.add(foreign);
       } else {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
         compiler.cancel('Unimplemented unresolved type variable',
                         node: currentNode);
       }
@@ skipping 12 matching lines @@
      */
     void buildTypeString(DartType type, {isInQuotes: false}) {
       if (type is TypeVariableType) {
         addTypeVariableReference(type);
         template.add(isInQuotes ? "' + # +'" : "#");
       } else if (type is InterfaceType) {
         bool isFirstVariable = true;
         InterfaceType interfaceType = type;
         bool hasTypeArguments = !interfaceType.arguments.isEmpty;
         if (!isInQuotes) template.add("'");
-        template.add(rti.getName(type.element));
+        template.add(backend.namer.getName(type.element,
+                                           allowUnsafeName: true));
         if (hasTypeArguments) {
           template.add("<");
           for (DartType argument in interfaceType.arguments) {
             if (!isFirstVariable) {
               template.add(", ");
             } else {
               isFirstVariable = false;
             }
             buildTypeString(argument, isInQuotes: true);
           }
           template.add(">");
         }
         if (!isInQuotes) template.add("'");
       } else {
         assert(type is TypedefType);
         if (!isInQuotes) template.add("'");
-        template.add(rti.getName(argument.element));
+        template.add(backend.namer.getName(argument.element,
+                                           allowUnsafeName: true));
         if (!isInQuotes) template.add("'");
       }
     }
 
     buildTypeString(argument, isInQuotes: false);
     HInstruction result =
         new HForeign(new LiteralDartString("$template"),
             new LiteralDartString('String'),
             inputs);
     add(result);
     return result;
   }
 
   void handleListConstructor(InterfaceType type,
                              Node currentNode,
                              HInstruction newObject) {
     if (!compiler.world.needsRti(type.element)) return;
     List<HInstruction> inputs = <HInstruction>[];
     type.arguments.forEach((DartType argument) {
       inputs.add(analyzeTypeArgument(argument, currentNode));
     });
     callSetRuntimeTypeInfo(type.element, inputs, newObject);
   }
 
   void callSetRuntimeTypeInfo(ClassElement element,
                               List<HInstruction> rtiInputs,
                               HInstruction newObject) {
-    bool needsRti = compiler.world.needsRti(element) && !rtiInputs.isEmpty;
-    bool runtimeTypeIsUsed = compiler.enabledRuntimeType;
-    if (!needsRti && !runtimeTypeIsUsed) return;
-
-    HInstruction createForeign(String template,
-                               List<HInstruction> arguments,
-                               [String type = 'String']) {
-      return new HForeign(new LiteralDartString(template),
-                          new LiteralDartString(type),
-                          arguments);
+    if (!compiler.world.needsRti(element) || element.typeVariables.isEmpty) {
+      return;
     }
 
-    // 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: '#'");
-    }
-    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('#');
-    }
-    HInstruction runtimeInfo =
-        createForeign("{$runtimeCode}", runtimeCodeInputs, 'Object');
-    add(runtimeInfo);
+    HInstruction typeInfo = new HLiteralList(rtiInputs);
+    add(typeInfo);
 
     // Set the runtime type information on the object.
     Element typeInfoSetterElement = interceptors.getSetRuntimeTypeInfo();
     HInstruction typeInfoSetter = new HStatic(typeInfoSetterElement);
     add(typeInfoSetter);
     add(new HInvokeStatic(
-        <HInstruction>[typeInfoSetter, newObject, runtimeInfo]));
+        <HInstruction>[typeInfoSetter, newObject, typeInfo]));
   }
 
   visitNewSend(Send node, InterfaceType type) {
     bool isListConstructor = false;
     computeType(element) {
       Element originalElement = elements[node];
       if (identical(originalElement.getEnclosingClass(), compiler.listClass)) {
         isListConstructor = true;
         if (node.arguments.isEmpty) {
           return HType.EXTENDABLE_ARRAY;
@@ skipping 34 matching lines @@
     if (constructor.getEnclosingClass().isAbstract(compiler) &&
         constructor.isGenerativeConstructor()) {
       generateAbstractClassInstantiationError(node, type.name.slowToString());
       return;
     }
     if (compiler.world.needsRti(constructor.enclosingElement)) {
       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
@@ skipping 64 matching lines @@
     Constant constant = constantSystem.createString(dartString, node);
     return graph.addConstant(constant);
   }
 
   visitTypeReferenceSend(Send node) {
     Element element = elements[node];
     HInstruction name;
     Element helper =
         compiler.findHelper(const SourceString('createRuntimeType'));
     if (element.isClass()) {
-      String string = rti.generateRuntimeTypeString(element, 0);
+      ClassElement classElement = element;
+      String string = backend.namer.getName(classElement,
+                                            allowUnsafeName: true);
+      if (!classElement.typeVariables.isEmpty) {
+        String arguments =
+            RuntimeTypeInformation.buildRawArguments(classElement);
+        string = "$string<$arguments>";
+      }
       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));
+      name = addConstantString(node.selector, backend.namer.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
@@ skipping 1559 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;
   }
 }