refactor: avoid parts

lib/src/codegen/js_codegen.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.
 
-library js_codegen;
-
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/dart/ast/token.dart'
     show StringToken, Token, TokenType;
 import 'package:analyzer/src/generated/type_system.dart'
     show StrongTypeSystemImpl;
 import 'package:analyzer/src/task/dart.dart' show PublicNamespaceBuilder;
 
 import 'ast_builder.dart' show AstBuilder;
 import 'reify_coercions.dart' show CoercionReifier, Tuple2;
 
-// TODO(jmesserly): import from its own package
 import '../js/js_ast.dart' as JS;
 import '../js/js_ast.dart' show js;
 
 import '../closure/closure_annotator.dart' show ClosureAnnotator;
 import '../compiler.dart'
     show AbstractCompiler, corelibOrder, getCorelibModuleName;
 import '../info.dart';
 import '../options.dart' show CodegenOptions;
 import '../utils.dart';
 
 import 'code_generator.dart';
 import 'js_field_storage.dart';
 import 'js_interop.dart';
 import 'js_names.dart' as JS;
 import 'js_metalet.dart' as JS;
 import 'js_module_item_order.dart';
 import 'js_names.dart';
 import 'js_printer.dart' show writeJsLibrary;
+import 'js_typeref_codegen.dart';
 import 'module_builder.dart';
 import 'nullability_inferrer.dart';
 import 'side_effect_analysis.dart';
 
-part 'js_typeref_codegen.dart';
-
 // Various dynamic helpers we call.
 // If renaming these, make sure to check other places like the
 // _runtime.js file and comments.
 // TODO(jmesserly): ideally we'd have a "dynamic call" dart library we can
 // import and generate calls to, rather than dart_runtime.js
 const DPUT = 'dput';
 const DLOAD = 'dload';
 const DINDEX = 'dindex';
 const DSETINDEX = 'dsetindex';
 const DCALL = 'dcall';
@@ skipping 32 matching lines @@
   final _privateNames = new HashMap<String, JS.TemporaryId>();
   final _moduleItems = <JS.Statement>[];
   final _temps = new HashMap<Element, JS.TemporaryId>();
   final _qualifiedIds = new List<Tuple2<Element, JS.MaybeQualifiedId>>();
 
   /// The name for the library's exports inside itself.
   /// `exports` was chosen as the most similar to ES module patterns.
   final _dartxVar = new JS.Identifier('dartx');
   final _exportsVar = new JS.TemporaryId('exports');
   final _runtimeLibVar = new JS.Identifier('dart');
-  final _namedArgTemp = new JS.TemporaryId('opts');
+  final namedArgumentTemp = new JS.TemporaryId('opts');
 
   final TypeProvider _types;
 
   ConstFieldVisitor _constField;
 
   ModuleItemLoadOrder _loader;
 
   /// _interceptors.JSArray<E>, used for List literals.
   ClassElement _jsArray;
 
@@ skipping 126 matching lines @@
     _jsModuleValue =
         getConstantField(jsName, 'name', types.stringType)?.toStringValue();
   }
 
   @override
   void visitImportDirective(ImportDirective node) {
     // Nothing to do yet, but we'll want to convert this to an ES6 import once
     // we have support for modules.
   }
 
-  @override void visitPartDirective(PartDirective node) {}
-  @override void visitPartOfDirective(PartOfDirective node) {}
+  @override
+  void visitPartDirective(PartDirective node) {}
+  @override
+  void visitPartOfDirective(PartOfDirective node) {}
 
   @override
   void visitExportDirective(ExportDirective node) {
-    var exportName = _libraryName(node.uriElement);
+    var exportName = emitLibraryName(node.uriElement);
 
     var currentLibNames = currentLibrary.publicNamespace.definedNames;
 
     var args = [_exportsVar, exportName];
     if (node.combinators.isNotEmpty) {
       var shownNames = <JS.Expression>[];
       var hiddenNames = <JS.Expression>[];
 
       var show = node.combinators.firstWhere((c) => c is ShowCombinator,
           orElse: () => null) as ShowCombinator;
@@ skipping 1068 matching lines @@
 
       if (param.kind == ParameterKind.NAMED) {
         if (!options.destructureNamedParams) {
           // Parameters will be passed using their real names, not the (possibly
           // renamed) local variable.
           var paramName = js.string(param.identifier.name, "'");
 
           // TODO(ochafik): Fix `'prop' in obj` to please Closure's renaming.
           body.add(js.statement('let # = # && # in # ? #.# : #;', [
             jsParam,
-            _namedArgTemp,
+            namedArgumentTemp,
             paramName,
-            _namedArgTemp,
-            _namedArgTemp,
+            namedArgumentTemp,
+            namedArgumentTemp,
             paramName,
             _defaultParamValue(param),
           ]));
         }
       } else if (param.kind == ParameterKind.POSITIONAL &&
           !options.destructureNamedParams) {
         body.add(js.statement('if (# === void 0) # = #;',
             [jsParam, jsParam, _defaultParamValue(param)]));
       }
 
@@ skipping 90 matching lines @@
 
     return annotate(
         new JS.Method(_elementMemberName(node.element), fn,
             isGetter: node.isGetter,
             isSetter: node.isSetter,
             isStatic: node.isStatic),
         node,
         node.element);
   }
 
-  /// Returns the name value of the `JSExportName` annotation (when compiling
-  /// the SDK), or `null` if there's none. This is used to control the name
-  /// under which functions are compiled and exported.
-  String _getJSExportName(Element e) {
-    if (!e.source.isInSystemLibrary) {
-      return null;
-    }
-    var jsName = findAnnotation(e, isJSExportNameAnnotation);
-    return getConstantField(jsName, 'name', types.stringType)?.toStringValue();
-  }
-
   @override
   JS.Statement visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.parent is CompilationUnit);
 
     if (_externalOrNative(node)) return null;
 
     if (node.isGetter || node.isSetter) {
       // Add these later so we can use getter/setter syntax.
       _properties.add(node);
       return null;
@@ skipping 12 matching lines @@
     }
 
     var id = new JS.Identifier(name);
     body.add(annotate(new JS.FunctionDeclaration(id, fn), node, node.element));
     if (!_isDartRuntime) {
       body.add(_emitFunctionTagged(id, node.element.type, topLevel: true)
           .toStatement());
     }
 
     if (isPublic(name)) {
-      _addExport(name, _getJSExportName(node.element) ?? name);
+      _addExport(name, getJSExportName(node.element, types) ?? name);
     }
     return _statement(body);
   }
 
   bool _isInlineJSFunction(FunctionExpression functionExpression) {
     var body = functionExpression.body;
     if (body is ExpressionFunctionBody) {
       return _isJSInvocation(body.expression);
     } else if (body is BlockFunctionBody) {
       if (body.block.statements.length == 1) {
@@ skipping 444 matching lines @@
       if (jsArgs != null) {
         var genericName = _emitTopLevelName(element, suffix: '\$');
         return js.call('#(#)', [genericName, jsArgs]);
       }
     }
 
     return _emitTopLevelName(element);
   }
 
   JS.Expression _emitTopLevelName(Element e, {String suffix: ''}) {
-    var libName = _libraryName(e.library);
+    var libName = emitLibraryName(e.library);
 
     // Always qualify:
     // * mutable top-level fields
     // * elements from other libraries
     bool mutableTopLevel = e is TopLevelVariableElement &&
         !e.isConst &&
         !_isFinalJSDecl(e.computeNode());
     bool fromAnotherLibrary = e.library != currentLibrary;
     var nameExpr;
     if (fromAnotherLibrary) {
-      nameExpr = _propertyName((_getJSExportName(e) ?? e.name) + suffix);
+      nameExpr = _propertyName((getJSExportName(e, types) ?? e.name) + suffix);
     } else {
       nameExpr = _propertyName(e.name + suffix);
     }
     if (mutableTopLevel || fromAnotherLibrary) {
       return new JS.PropertyAccess(libName, nameExpr);
     }
 
     var id = new JS.MaybeQualifiedId(libName, nameExpr);
     _qualifiedIds.add(new Tuple2(e, id));
     return id;
@@ skipping 287 matching lines @@
       } else {
         var jsParam = _visit(param);
         result.add(param is DefaultFormalParameter && destructure
             ? new JS.DestructuredVariable(
                 name: jsParam, defaultValue: _defaultParamValue(param))
             : jsParam);
       }
     }
 
     if (needsOpts) {
-      result.add(_namedArgTemp);
+      result.add(namedArgumentTemp);
     } else if (namedVars.isNotEmpty) {
       // Note: `var {valueOf} = {}` extracts `Object.prototype.valueOf`, so
       // in case there are conflicting names we create an object without
       // any prototype.
       var defaultOpts = hasNamedArgsConflictingWithObjectProperties
           ? js.call('Object.create(null)')
           : js.call('{}');
       result.add(new JS.DestructuredVariable(
           structure: new JS.ObjectBindingPattern(namedVars),
           type: emitNamedParamsArgType(node.parameterElements),
@@ skipping 202 matching lines @@
     }
 
     // Treat `final x = JS('', '...')` as a const (non-lazy) to help compile
     // runtime helpers.
     var isJSTopLevel = field.isFinal && _isFinalJSDecl(field);
     if (isJSTopLevel) eagerInit = true;
 
     var fieldName = field.name.name;
     var exportName = fieldName;
     if (element is TopLevelVariableElement) {
-      exportName = _getJSExportName(element) ?? fieldName;
+      exportName = getJSExportName(element, types) ?? fieldName;
     }
     if ((field.isConst && eagerInit && element is TopLevelVariableElement) ||
         isJSTopLevel) {
       // constant fields don't change, so we can generate them as `let`
       // but add them to the module's exports. However, make sure we generate
       // anything they depend on first.
 
       if (isPublic(fieldName)) _addExport(fieldName, exportName);
       var declKeyword = field.isConst || field.isFinal ? 'const' : 'let';
       if (isJSTopLevel && jsInit is JS.ClassExpression) {
@@ skipping 50 matching lines @@
                 isSetter: true),
             node,
             _findAccessor(element, getter: false)));
       }
     }
 
     JS.Expression objExpr;
     if (target is ClassElement) {
       objExpr = new JS.Identifier(target.type.name);
     } else {
-      objExpr = _libraryName(target);
+      objExpr = emitLibraryName(target);
     }
 
     return js
         .statement('dart.defineLazyProperties(#, { # });', [objExpr, methods]);
   }
 
   PropertyAccessorElement _findAccessor(VariableElement element,
       {bool getter}) {
     var parent = element.enclosingElement;
     if (parent is ClassElement) {
@@ skipping 930 matching lines @@
 
   _visit(AstNode node) {
     if (node == null) return null;
     var result = node.accept(this);
     if (result is JS.Node) result = annotate(result, node);
     return result;
   }
 
   // TODO(jmesserly): this will need to be a generic method, if we ever want to
   // self-host strong mode.
-  List /*<T>*/ _visitList /*<T>*/ (Iterable<AstNode> nodes) {
+  List/*<T>*/ _visitList/*<T>*/(Iterable<AstNode> nodes) {
     if (nodes == null) return null;
     var result = /*<T>*/ [];
     for (var node in nodes) result.add(_visit(node));
     return result;
   }
 
   /// Visits a list of expressions, creating a comma expression if needed in JS.
   JS.Expression _visitListToBinary(List<Expression> nodes, String operator) {
     if (nodes == null || nodes.isEmpty) return null;
     return new JS.Expression.binary(
@@ skipping 107 matching lines @@
 
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
   FunctionBody _functionBody(node) =>
       node is FunctionDeclaration ? node.functionExpression.body : node.body;
 
   /// Choose a canonical name from the library element.
   /// This never uses the library's name (the identifier in the `library`
   /// declaration) as it doesn't have any meaningful rules enforced.
-  JS.Identifier _libraryName(LibraryElement library) {
+  JS.Identifier emitLibraryName(LibraryElement library) {
     if (library == currentLibrary) return _exportsVar;
     if (library.name == 'dart._runtime') return _runtimeLibVar;
     return _imports.putIfAbsent(
         library, () => new JS.TemporaryId(jsLibraryName(library)));
   }
 
   DartType getStaticType(Expression e) =>
       e.staticType ?? DynamicTypeImpl.instance;
 
   JS.Node annotate(JS.Node node, AstNode original, [Element element]) {
     if (options.closure && element != null) {
-      node = node.withClosureAnnotation(
-          closureAnnotationFor(node, original, element, _namedArgTemp.name));
+      node = node.withClosureAnnotation(closureAnnotationFor(
+          node, original, element, namedArgumentTemp.name));
     }
     return node..sourceInformation = original;
   }
 
   /// Returns true if this is any kind of object represented by `Number` in JS.
   ///
   /// In practice, this is 4 types: num, int, double, and JSNumber.
   ///
   /// JSNumber is the type that actually "implements" all numbers, hence it's
   /// a subtype of int and double (and num). It's in our "dart:_interceptors".
@@ skipping 155 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }