optimize extension member symbols in DDC, issue #30531

pkg/dev_compiler/lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, 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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 100 matching lines @@
   /// In an async* function, this represents the stream controller parameter.
   JS.TemporaryId _asyncStarController;
 
   // TODO(jmesserly): fuse this with notNull check.
   final _privateNames =
       new HashMap<LibraryElement, HashMap<String, JS.TemporaryId>>();
   final _initializingFormalTemps =
       new HashMap<ParameterElement, JS.TemporaryId>();
 
   JS.Identifier _extensionSymbolsModule;
+  final _extensionSymbols = new Map<String, JS.TemporaryId>();
+
   JS.Identifier _runtimeModule;
   final namedArgumentTemp = new JS.TemporaryId('opts');
 
   final _hasDeferredSupertype = new HashSet<ClassElement>();
 
   /// The  type provider from the current Analysis [context].
   final TypeProvider types;
 
   final LibraryElement dartCoreLibrary;
   final LibraryElement dartJSLibrary;
@@ skipping 180 matching lines @@
       _extensionSymbolsModule = new JS.Identifier('dartx');
     } else {
       // Otherwise allow these to be renamed so users can write them.
       _runtimeModule = new JS.TemporaryId('dart');
       _extensionSymbolsModule = new JS.TemporaryId('dartx');
     }
     _typeTable = new TypeTable(_runtimeModule);
 
     // Initialize our library variables.
     var items = <JS.ModuleItem>[];
+    var isBuildingSdk = false;
     for (var unit in compilationUnits) {
       var library =
           resolutionMap.elementDeclaredByCompilationUnit(unit).library;
       if (unit.element != library.definingCompilationUnit) continue;
 
       var libraryTemp = isSdkInternalRuntime(library)
           ? _runtimeModule
           : new JS.TemporaryId(jsLibraryName(_libraryRoot, library));
       _libraries[library] = libraryTemp;
       items.add(new JS.ExportDeclaration(
           js.call('const # = Object.create(null)', [libraryTemp])));
 
       // dart:_runtime has a magic module that holds extension method symbols.
       // TODO(jmesserly): find a cleaner design for this.
       if (isSdkInternalRuntime(library)) {
+        isBuildingSdk = true;
         items.add(new JS.ExportDeclaration(js
             .call('const # = Object.create(null)', [_extensionSymbolsModule])));
       }
     }
 
     // Collect all class/type Element -> Node mappings
     // in case we need to forward declare any classes.
     _declarationNodes = new HashMap<TypeDefiningElement, AstNode>.identity();
     for (var unit in compilationUnits) {
       for (var declaration in unit.declarations) {
@@ skipping 19 matching lines @@
     // Order will be changed as needed so the resulting code can execute.
     // This is done by forward declaring items.
     compilationUnits.forEach(visitCompilationUnit);
     assert(_deferredProperties.isEmpty);
 
     // Visit directives (for exports)
     compilationUnits.forEach(_emitExportDirectives);
 
     // Declare imports
     _finishImports(items);
+    // Initialize extension symbols
+    _extensionSymbols.forEach((name, id) {
+      var value =
+          new JS.PropertyAccess(_extensionSymbolsModule, _propertyName(name));
+      if (isBuildingSdk) {
+        value = js.call('# = Symbol(#)', [value, js.string("dartx.$name")]);
+      }
+      items.add(js.statement('const # = #;', [id, value]));
+    });
 
     // Discharge the type table cache variables and
     // hoisted definitions.
     items.addAll(_typeTable.discharge());
     items.addAll(_internalSdkFunctions);
 
     // Track the module name for each library in the module.
     // This data is only required for debugging.
     _moduleItems.add(js.statement(
         '#.trackLibraries(#, #, ${JSModuleFile.sourceMapHoleID});',
@@ skipping 541 matching lines @@
         virtualFields,
         classElem,
         getClassCovariantParameters(node),
         _usedCovariantPrivateMembers);
 
     var jsCtors = _defineConstructors(classElem, className, fields, ctors);
     var classExpr = _emitClassExpression(classElem, _emitClassMethods(node),
         fields: allFields);
 
     var body = <JS.Statement>[];
-    _initExtensionSymbols(classElem, methods, fields, body);
     _emitSuperHelperSymbols(body);
 
     // Emit the class, e.g. `core.Object = class Object { ... }`
     _defineClass(classElem, className, classExpr, body);
     body.addAll(jsCtors);
 
     // Emit things that come after the ES6 `class ... { ... }`.
     var jsPeerNames = _getJSPeerNames(classElem);
     JS.Statement deferredBaseClass =
         _setBaseClass(classElem, className, jsPeerNames, body);
@@ skipping 224 matching lines @@
     // Define the type tests on the default instantiation to check for that
     // marker.
     var defaultInst = _emitTopLevelName(classElem);
 
     // Return this `addTypeTests` call so we can emit it outside of the generic
     // type parameter scope.
     return _callHelperStatement(
         'addTypeTests(#, #);', [defaultInst, isClassSymbol]);
   }
 
-  void _emitSuperHelperSymbols(List<JS.Statement> body) {
-    for (var id in _superHelpers.values.map((m) => m.name as JS.TemporaryId)) {
+  void _emitSymbols(Iterable<JS.TemporaryId> vars, List<JS.ModuleItem> body) {
+    for (var id in vars) {
       body.add(js.statement('const # = Symbol(#)', [id, js.string(id.name)]));
     }
+  }
+
+  void _emitSuperHelperSymbols(List<JS.Statement> body) {
+    _emitSymbols(
+        _superHelpers.values.map((m) => m.name as JS.TemporaryId), body);
     _superHelpers.clear();
   }
 
   void _emitVirtualFieldSymbols(
       ClassElement classElement, List<JS.Statement> body) {
     _classProperties.virtualFields.forEach((field, virtualField) {
       body.add(js.statement('const # = Symbol(#);',
           [virtualField, js.string('${classElement.name}.${field.name}')]));
     });
   }
@@ skipping 953 matching lines @@
       body.add(_callHelperStatement('setSignature(#, #);', [className, sig]));
     }
     // Add static property dart._runtimeType to Object.
     // All other Dart classes will (statically) inherit this property.
     if (classElem == objectClass) {
       body.add(_callHelperStatement('tagComputed(#, () => #.#);',
           [className, emitLibraryName(dartCoreLibrary), 'Type']));
     }
   }
 
-  /// Ensure `dartx.` symbols we will use are present.
-  void _initExtensionSymbols(
-      ClassElement classElem,
-      List<MethodDeclaration> methods,
-      List<FieldDeclaration> fields,
-      List<JS.Statement> body) {
-    if (_extensionTypes.hasNativeSubtype(classElem.type)) {
-      var dartxNames = <JS.Expression>[];
-      for (var m in methods) {
-        if (!m.isAbstract &&
-            !m.isStatic &&
-            resolutionMap.elementDeclaredByMethodDeclaration(m).isPublic) {
-          dartxNames.add(_declareMemberName(m.element, useExtension: false));
-        }
-      }
-      for (var fieldDecl in fields) {
-        if (!fieldDecl.isStatic) {
-          for (var field in fieldDecl.fields.variables) {
-            var e = field.element as FieldElement;
-            if (e.isPublic) {
-              dartxNames.add(_declareMemberName(e.getter, useExtension: false));
-            }
-          }
-        }
-      }
-      if (dartxNames.isNotEmpty) {
-        body.add(_callHelperStatement('defineExtensionNames(#)',
-            [new JS.ArrayInitializer(dartxNames, multiline: true)]));
-      }
-    }
-  }
-
   JS.Expression _emitConstructor(ConstructorDeclaration node,
       List<FieldDeclaration> fields, bool isCallable, JS.Expression className) {
     var params = _emitFormalParameterList(node.parameters);
 
     var savedFunction = _currentFunction;
     _currentFunction = node.body;
 
     var savedSuperAllowed = _superAllowed;
     _superAllowed = false;
     var body = _emitConstructorBody(node, fields, className);
@@ skipping 3447 matching lines @@
         break;
       case 'unary-':
         name = '_negate';
         break;
       case 'constructor':
       case 'prototype':
         name = '_$name';
         break;
     }
 
-    var result = _propertyName(name);
-
-    useExtension ??= _isSymbolizedMember(type, name);
-
-    return useExtension
-        ? js.call('#.#', [_extensionSymbolsModule, result])
-        : result;
+    if (useExtension ?? _isSymbolizedMember(type, name)) {
+      return _extensionSymbols.putIfAbsent(name,
+          () => new JS.TemporaryId('\$${_friendlyOperatorName[name] ?? name}'));
+    }
+    return _propertyName(name);
   }
 
   var _forwardingCache = new HashMap<Element, Map<String, ExecutableElement>>();
 
   Element _lookupForwardedMember(ClassElement element, String name) {
     // We only care about public methods.
     if (name.startsWith('_')) return null;
 
     var map = _forwardingCache.putIfAbsent(element, () => {});
     if (map.containsKey(name)) return map[name];
@@ skipping 391 matching lines @@
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }
 
 bool _annotatedNullCheck(Element e) =>
     e != null && findAnnotation(e, isNullCheckAnnotation) != null;
+
+final _friendlyOperatorName = {
+  '<': 'lessThan',
+  '>': 'greaterThan',
+  '<=': 'lessOrEquals',
+  '>=': 'greaterOrEquals',
+  '==': 'equals',
+  '-': 'minus',
+  '+': 'plus',
+  '/': 'divide',
+  '~/': 'floorDivide',
+  '*': 'times',
+  '%': 'modulo',
+  '|': 'bitOr',
+  '^': 'bitXor',
+  '&': 'bitAnd',
+  '<<': 'leftShift',
+  '>>': 'rightShift',
+  '~': 'bitNot'
+};