Use elements/types in constants/values

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.
 
 library js_backend.namer;
 
 import 'dart:collection' show HashMap;
 
 import 'package:js_runtime/shared/embedded_names.dart' show JsGetName;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
 import '../core_types.dart' show CommonElements;
 import '../elements/resolution_types.dart';
 import '../diagnostics/invariant.dart' show DEBUG_MODE;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../js/js.dart' as jsAst;
 import '../js/js.dart' show js;
 import '../tree/tree.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector, SelectorKind;
+import '../universe/world_builder.dart' show CodegenWorldBuilder;
 import '../util/characters.dart';
 import '../util/util.dart';
 import '../world.dart' show ClosedWorld;
 import 'backend.dart';
 import 'backend_helpers.dart';
 import 'constant_system_javascript.dart';
 
 part 'field_naming_mixin.dart';
 part 'frequency_namer.dart';
 part 'minify_namer.dart';
@@ skipping 361 matching lines @@
   jsAst.Name get rtiFieldName => _rtiFieldName ??= new StringBackedName(r'$ti');
 
   // Name of property in a class description for the native dispatch metadata.
   final String nativeSpecProperty = '%';
 
   static final RegExp IDENTIFIER = new RegExp(r'^[A-Za-z_$][A-Za-z0-9_$]*$');
   static final RegExp NON_IDENTIFIER_CHAR = new RegExp(r'[^A-Za-z_0-9$]');
 
   final JavaScriptBackend backend;
   final ClosedWorld closedWorld;
+  final CodegenWorldBuilder codegenWorldBuilder;
 
   /// Used disambiguated names in the global namespace, issued by
   /// [_disambiguateGlobal], and [_disambiguateInternalGlobal].
   ///
   /// Although global names are distributed across a number of global objects,
   /// (see [globalObjectFor]), we currently use a single namespace for all these
   /// names.
   final NamingScope globalScope = new NamingScope();
   final Map<Element, jsAst.Name> userGlobals =
       new HashMap<Element, jsAst.Name>();
@@ skipping 36 matching lines @@
 
   final Map<String, String> suggestedGlobalNames = <String, String>{};
   final Map<String, String> suggestedInstanceNames = <String, String>{};
 
   /// Used to store unique keys for library names. Keys are not used as names,
   /// nor are they visible in the output. The only serve as an internal
   /// key into maps.
   final Map<LibraryElement, String> _libraryKeys =
       new HashMap<LibraryElement, String>();
 
-  Namer(JavaScriptBackend backend, this.closedWorld)
+  Namer(JavaScriptBackend backend, this.closedWorld,
+      CodegenWorldBuilder codegenWorldBuilder)
       : this.backend = backend,
-        constantHasher =
-            new ConstantCanonicalHasher(backend.rtiEncoder, backend.reporter),
+        this.codegenWorldBuilder = codegenWorldBuilder,
+        constantHasher = new ConstantCanonicalHasher(
+            backend.rtiEncoder, backend.reporter, codegenWorldBuilder),
         functionTypeNamer = new FunctionTypeNamer(backend.rtiEncoder) {
     _literalAsyncPrefix = new StringBackedName(asyncPrefix);
     _literalGetterPrefix = new StringBackedName(getterPrefix);
     _literalSetterPrefix = new StringBackedName(setterPrefix);
     _literalLazyGetterPrefix = new StringBackedName(lazyGetterPrefix);
   }
 
   BackendHelpers get helpers => backend.helpers;
 
   DiagnosticReporter get reporter => backend.reporter;
@@ skipping 108 matching lines @@
       constantNames[constant] = result;
     }
     return _newReference(result);
   }
 
   /// Proposed name for [constant].
   String constantLongName(ConstantValue constant) {
     String longName = constantLongNames[constant];
     if (longName == null) {
       longName = new ConstantNamingVisitor(
-              backend.rtiEncoder, reporter, constantHasher)
+              backend.rtiEncoder, reporter, codegenWorldBuilder, constantHasher)
           .getName(constant);
       constantLongNames[constant] = longName;
     }
     return longName;
   }
 
   String breakLabelName(LabelDefinition label) {
     return '\$${label.labelName}\$${label.target.nestingLevel}';
   }
 
@@ skipping 1032 matching lines @@
  *
  */
 class ConstantNamingVisitor implements ConstantValueVisitor {
   static final RegExp IDENTIFIER = new RegExp(r'^[A-Za-z_$][A-Za-z0-9_$]*$');
   static const MAX_FRAGMENTS = 5;
   static const MAX_EXTRA_LENGTH = 30;
   static const DEFAULT_TAG_LENGTH = 3;
 
   final RuntimeTypesEncoder rtiEncoder;
   final DiagnosticReporter reporter;
+  final CodegenWorldBuilder codegenWorldBuilder;
   final ConstantCanonicalHasher hasher;
 
   String root = null; // First word, usually a type name.
   bool failed = false; // Failed to generate something pretty.
   List<String> fragments = <String>[];
   int length = 0;
 
-  ConstantNamingVisitor(this.rtiEncoder, this.reporter, this.hasher);
+  ConstantNamingVisitor(
+      this.rtiEncoder, this.reporter, this.codegenWorldBuilder, this.hasher);
 
   String getName(ConstantValue constant) {
     _visit(constant);
     if (root == null) return 'CONSTANT';
     if (failed) return '${root}_${getHashTag(constant, DEFAULT_TAG_LENGTH)}';
     if (fragments.length == 1) return 'C_${root}';
     return fragments.join('_');
   }
 
   String getHashTag(ConstantValue constant, int width) =>
@@ skipping 108 matching lines @@
     } else {
       // Using some bits from the keys hash tag groups the names Maps with the
       // same structure.
       add(getHashTag(constant.keyList, 2) + getHashTag(constant, 3));
     }
   }
 
   @override
   void visitConstructed(ConstructedConstantValue constant, [_]) {
     addRoot(constant.type.element.name);
-    constant.type.element.forEachInstanceField((_, FieldElement field) {
+    codegenWorldBuilder.forEachInstanceField(constant.type.element,

[Siggi Cherem (dart-lang), 2017/01/11 22:57:47]

interesting - correct me if I'm wrong, but I thought `namer` was invoked after
we are done with codegen (since we now know everything that was added to the
codegenworld and then we can figure out which names are are more frequent).

If so, this might be a motivation to move `forEachInstanceField` into closed
world and not pass the codegenWorldBuilder to the namer altogether.

WDTY?

[Johnni Winther, 2017/01/12 11:17:45]

I agree. We should create a ClosedWorld for codegen and pull it from there.
Adding a TODO.

+        (_, FieldElement field) {
       if (failed) return;
       _visit(constant.fields[field]);
-    }, includeSuperAndInjectedMembers: true);
+    });
   }
 
   @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');
     ResolutionDartType type = constant.representedType;
     String name = type.element?.name;
     if (name == null) {
       // e.g. DartType 'dynamic' has no element.
       name = rtiEncoder.getTypeRepresentationForTypeConstant(type);
     }
     addIdentifier(name);
     add(getHashTag(constant, 3));
   }
 
   @override
   void visitInterceptor(InterceptorConstantValue constant, [_]) {
-    addRoot(constant.dispatchedType.element.name);
+    addRoot(constant.cls.name);
     add('methods');
   }
 
   @override
   void visitSynthetic(SyntheticConstantValue constant, [_]) {
     switch (constant.valueKind) {
       case SyntheticConstantKind.DUMMY_INTERCEPTOR:
         add('dummy_receiver');
         break;
       case SyntheticConstantKind.TYPEVARIABLE_REFERENCE:
@@ skipping 21 matching lines @@
  * so it can't be used for generating names.  This hasher keeps consistency
  * between runs by basing hash values of the names of elements, rather than
  * their hashCodes.
  */
 class ConstantCanonicalHasher implements ConstantValueVisitor<int, Null> {
   static const _MASK = 0x1fffffff;
   static const _UINT32_LIMIT = 4 * 1024 * 1024 * 1024;
 
   final DiagnosticReporter reporter;
   final RuntimeTypesEncoder rtiEncoder;
+  final CodegenWorldBuilder codegenWorldBuilder;
   final Map<ConstantValue, int> hashes = new Map<ConstantValue, int>();
 
-  ConstantCanonicalHasher(this.rtiEncoder, this.reporter);
+  ConstantCanonicalHasher(
+      this.rtiEncoder, this.reporter, this.codegenWorldBuilder);
 
   int getHash(ConstantValue constant) => _visit(constant);
 
   int _visit(ConstantValue constant) {
     int hash = hashes[constant];
     if (hash == null) {
       hash = _finish(constant.accept(this, null));
       hashes[constant] = hash;
     }
     return hash;
@@ skipping 37 matching lines @@
 
   @override
   int visitMap(MapConstantValue constant, [_]) {
     int hash = _hashList(constant.length, constant.keys);
     return _hashList(hash, constant.values);
   }
 
   @override
   int visitConstructed(ConstructedConstantValue constant, [_]) {
     int hash = _hashString(3, constant.type.element.name);
-    constant.type.element.forEachInstanceField((_, FieldElement field) {
+    codegenWorldBuilder.forEachInstanceField(constant.type.element,
+        (_, FieldElement field) {
       hash = _combine(hash, _visit(constant.fields[field]));
-    }, includeSuperAndInjectedMembers: true);
+    });
     return hash;
   }
 
   @override
   int visitType(TypeConstantValue constant, [_]) {
     ResolutionDartType type = constant.representedType;
     // This name includes the library name and type parameters.
     String name = rtiEncoder.getTypeRepresentationForTypeConstant(type);
     return _hashString(4, name);
   }
 
   @override
   int visitInterceptor(InterceptorConstantValue constant, [_]) {
-    String typeName = constant.dispatchedType.element.name;
+    String typeName = constant.cls.name;
     return _hashString(5, typeName);
   }
 
   @override
   int visitSynthetic(SyntheticConstantValue constant, [_]) {
     switch (constant.valueKind) {
       case SyntheticConstantKind.TYPEVARIABLE_REFERENCE:
         // 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're always part of a larger constant.
@@ skipping 159 matching lines @@
   void addSuggestion(String original, String suggestion) {
     assert(!_suggestedNames.containsKey(original));
     _suggestedNames[original] = suggestion;
   }
 
   bool hasSuggestion(String original) => _suggestedNames.containsKey(original);
   bool isSuggestion(String candidate) {
     return _suggestedNames.containsValue(candidate);
   }
 }