dart2js: fix nondeterministic output of type metadata.

pkg/compiler/lib/src/js_backend/namer.dart

 // Copyright (c) 2011, 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 js_backend;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  *
  * Names are generated through three stages:
@@ skipping 1692 matching lines @@
   void visitConstructed(ConstructedConstantValue constant, [_]) {
     addRoot(constant.type.element.name);
     for (ConstantValue value in constant.fields.values) {
       _visit(value);
       if (failed) return;
     }
   }
 
   @override
   void visitType(TypeConstantValue constant, [_]) {
+    // Generates something like 'Type_String_k8F', using the simple name of the
+    // type and a hash to disambiguate the same name in different libraries.
     addRoot('Type');
     DartType type = constant.representedType;
-    JavaScriptBackend backend = compiler.backend;
-    String name = backend.rti.getTypeRepresentationForTypeConstant(type);
-    addIdentifier(name);
+    String simpleName = type.element.name;
+    addIdentifier(simpleName);
+    add(getHashTag(constant, 3));
   }
 
   @override
   void visitInterceptor(InterceptorConstantValue constant, [_]) {
     addRoot(constant.dispatchedType.element.name);
     add('methods');
   }
 
   @override
   void visitSynthetic(SyntheticConstantValue constant, [_]) {
     switch (constant.kind) {
       case SyntheticConstantKind.DUMMY_INTERCEPTOR:
         add('dummy_receiver');
         break;
       case SyntheticConstantKind.TYPEVARIABLE_REFERENCE:
-        add('type_variable_reference');
+        // Omit. These are opaque deferred indexes with nothing helpful to add.
         break;
       case SyntheticConstantKind.NAME:
         add('name');
         break;
       default:
         compiler.internalError(compiler.currentElement,
                                "Unexpected SyntheticConstantValue");
     }
   }
 
@@ skipping 78 matching lines @@
     for (ConstantValue value in constant.fields.values) {
       hash = _combine(hash, _visit(value));
     }
     return hash;
   }
 
   @override
   int visitType(TypeConstantValue constant, [_]) {
     DartType type = constant.representedType;
     JavaScriptBackend backend = compiler.backend;
+    // This name includes the library name and type parameters.
     String name = backend.rti.getTypeRepresentationForTypeConstant(type);
     return _hashString(4, name);
   }
 
   @override
   int visitInterceptor(InterceptorConstantValue constant, [_]) {
     String typeName = constant.dispatchedType.element.name;
     return _hashString(5, typeName);
   }
 
   @override
-  visitSynthetic(SyntheticConstantValue constant, [_]) {
+  int visitSynthetic(SyntheticConstantValue constant, [_]) {

[Harry Terkelsen, 2015/09/23 17:36:25]

this would be clearer if it was:
if (constant.kind != SytheticConstantKind.TYPEVARIABLEREFERENCE) {
  compiler.internalError(...);
}
// These contain ...
return 0;

[sra1, 2015/09/23 22:52:05]

I'd like to keep it as-is since other visitSynthetic methods have a switch with
multiple cases.

     switch (constant.kind) {
       case SyntheticConstantKind.TYPEVARIABLE_REFERENCE:
-        return constant.payload.hashCode;
+        // These contain a deferred opaque index into metadata. There is nothing
+        // we can access that is stable between compiles.  Luckily, since they
+        // resolve to integer indexes, they always part of a larger constant.

[Harry Terkelsen, 2015/09/23 17:36:25]

nit: they always -> they're always

[sra1, 2015/09/23 22:52:05]

Done.

+        return 0;
       default:
         compiler.internalError(NO_LOCATION_SPANNABLE,
                                'SyntheticConstantValue should never be named and '
                                'never be subconstant');
-        return null;
+        return 0;
     }
   }
 
   @override
   int visitDeferred(DeferredConstantValue constant, [_]) {
     int hash = constant.prefix.hashCode;
     return _combine(hash, _visit(constant.referenced));
   }
 
   int _hashString(int hash, String s) {
@@ skipping 120 matching lines @@
       }
     }
   }
 }
 
 enum NamingScope {
   global,
   instance,
   constant
 }