Give different runtime type representations to different types with the same name.

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 835 matching lines @@
   final SsaBuilderTask builder;
   final JavaScriptBackend backend;
   final Interceptors interceptors;
   final WorkItem work;
   final ConstantSystem constantSystem;
   bool methodInterceptionEnabled;
   HGraph graph;
   LocalsHandler localsHandler;
   HInstruction rethrowableException;
   Map<Element, HParameterValue> parameters;
+  final RuntimeTypeInformation rti;
 
   Map<TargetElement, JumpHandler> jumpTargets;
 
   /**
    * Variables stored in the current activation. These variables are
    * being updated in try/catch blocks, and should be
    * accessed indirectly through [HLocalGet] and [HLocalSet].
    */
   Map<Element, HLocalValue> activationVariables;
 
@@ skipping 21 matching lines @@
       this.work = work,
       interceptors = builder.interceptors,
       methodInterceptionEnabled = true,
       graph = new HGraph(),
       stack = new List<HInstruction>(),
       activationVariables = new Map<Element, HLocalValue>(),
       jumpTargets = new Map<TargetElement, JumpHandler>(),
       parameters = new Map<Element, HParameterValue>(),
       sourceElementStack = <Element>[work.element],
       inliningStack = <InliningState>[],
+      rti = builder.compiler.codegenWorld.rti,
       super(work.resolutionTree) {
     localsHandler = new LocalsHandler(this);
   }
 
   static const MAX_INLINING_DEPTH = 3;
   static const MAX_INLINING_SOURCE_SIZE = 100;
   List<InliningState> inliningStack;
   Element returnElement = null;
 
   void disableMethodInterception() {
@@ skipping 1878 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("${type.element.name.slowToString()}");
+        template.add(rti.getName(type.element));
         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(argument.toString());
+        template.add(rti.getName(argument.element));
         if (!isInQuotes) template.add("'");
       }
     }
 
     buildTypeString(argument, isInQuotes: false);
     HInstruction result =
         new HForeign(new LiteralDartString("$template"),
             new LiteralDartString('String'),
             inputs);
     add(result);
@@ skipping 24 matching lines @@
       return new HForeign(new LiteralDartString(template),
                           new LiteralDartString(type),
                           arguments);
     }
 
     // Construct the runtime type information.
     StringBuffer runtimeCode = new StringBuffer();
     List<HInstruction> runtimeCodeInputs = <HInstruction>[];
     if (runtimeTypeIsUsed) {
       String runtimeTypeString =
-          RuntimeTypeInformation.generateRuntimeTypeString(element,
-                                                           rtiInputs.length);
+          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);
@@ skipping 1585 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;
   }
 }