Optimize DDC private library files.

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 26 matching lines @@
 import '../js_ast/js_ast.dart' as JS;
 import '../js_ast/js_ast.dart' show js;
 import 'ast_builder.dart' show AstBuilder;
 import 'compiler.dart' show BuildUnit, CompilerOptions, JSModuleFile;
 import 'element_helpers.dart';
 import 'extension_types.dart' show ExtensionTypeSet;
 import 'js_interop.dart';
 import 'js_metalet.dart' as JS;
 import 'js_names.dart' as JS;
 import 'js_typeref_codegen.dart' show JsTypeRefCodegen;
-import 'js_typerep.dart' show JSTypeRep;
+import 'js_typerep.dart' show JSTypeRep, JSType;
 import 'module_builder.dart' show pathToJSIdentifier;
 import 'nullable_type_inference.dart' show NullableTypeInference;
 import 'property_model.dart';
 import 'reify_coercions.dart' show CoercionReifier;
 import 'side_effect_analysis.dart' show ConstFieldVisitor, isStateless;
 import 'type_utilities.dart';
 
 /// The code generator for Dart Dev Compiler.
 ///
 /// Takes as input resolved Dart ASTs for every compilation unit in every
@@ skipping 70 matching lines @@
 
   final LibraryElement dartCoreLibrary;
   final LibraryElement dartJSLibrary;
 
   /// The dart:async `StreamIterator<>` type.
   final InterfaceType _asyncStreamIterator;
 
   /// The dart:core `identical` element.
   final FunctionElement _coreIdentical;
 
-  /// The dart:_interceptors JSArray element.
+  /// The dart:_interceptors implementation elements.
   final ClassElement _jsArray;
+  final ClassElement _jsBool;
+  final ClassElement _jsNumber;
+  final ClassElement _jsString;
 
   final ClassElement boolClass;
   final ClassElement intClass;
   final ClassElement interceptorClass;
   final ClassElement nullClass;
   final ClassElement numClass;
   final ClassElement objectClass;
   final ClassElement stringClass;
   final ClassElement functionClass;
   final ClassElement privateSymbolClass;
@@ skipping 48 matching lines @@
   CodeGenerator(
       AnalysisContext c, this.summaryData, this.options, this._extensionTypes)
       : context = c,
         rules = new StrongTypeSystemImpl(c.typeProvider),
         types = c.typeProvider,
         _asyncStreamIterator =
             _getLibrary(c, 'dart:async').getType('StreamIterator').type,
         _coreIdentical =
             _getLibrary(c, 'dart:core').publicNamespace.get('identical'),
         _jsArray = _getLibrary(c, 'dart:_interceptors').getType('JSArray'),
+        _jsBool = _getLibrary(c, 'dart:_interceptors').getType('JSBool'),
+        _jsString = _getLibrary(c, 'dart:_interceptors').getType('JSString'),
+        _jsNumber = _getLibrary(c, 'dart:_interceptors').getType('JSNumber'),
         interceptorClass =
             _getLibrary(c, 'dart:_interceptors').getType('Interceptor'),
         dartCoreLibrary = _getLibrary(c, 'dart:core'),
         boolClass = _getLibrary(c, 'dart:core').getType('bool'),
         intClass = _getLibrary(c, 'dart:core').getType('int'),
         numClass = _getLibrary(c, 'dart:core').getType('num'),
         nullClass = _getLibrary(c, 'dart:core').getType('Null'),
         objectClass = _getLibrary(c, 'dart:core').getType('Object'),
         stringClass = _getLibrary(c, 'dart:core').getType('String'),
         functionClass = _getLibrary(c, 'dart:core').getType('Function'),
@@ skipping 2207 matching lines @@
           body.add(js.statement('if (# === void 0) # = #;',
               [jsParam, jsParam, _defaultParamValue(param)]));
         }
       }
 
       var paramElement = resolutionMap.elementDeclaredByFormalParameter(param);
       if (_isCovariant(paramElement)) {
         var castType = _emitType(paramElement.type);
         body.add(js.statement('#._check(#);', [castType, jsParam]));
       }
+      if (_annotatedNullCheck(paramElement)) {
+        body.add(nullParameterCheck(jsParam));
+      }
     }
     return body.isEmpty ? null : _statement(body);
   }
 
   bool _isCovariant(ParameterElement p) {
     if (p.isCovariant) return true;
     var covariantParams = _classProperties?.covariantParameters;
     return covariantParams != null && covariantParams.contains(p);
   }
 
@@ skipping 815 matching lines @@
       var t = _bindValue(vars, 't', x, context: x);
       return new JS.MetaLet(vars, [
         js.call('# == null ? # : #', [_visit(t), _emitSet(x, right), _visit(t)])
       ]);
     }
 
     // Desugar `x += y` as `x = x + y`, ensuring that if `x` has subexpressions
     // (for example, x is IndexExpression) we evaluate those once.
     var vars = <JS.MetaLetVariable, JS.Expression>{};
     var lhs = _bindLeftHandSide(vars, left, context: context);
+    // TODO(leafp): The element for lhs here will be the setter element
+    // instead of the getter element if lhs is a property access. This
+    // interferes with nullability analysis.

[Jennifer Messerly, 2017/08/22 21:54:41]

FYI ... I think it would be safe to fix _bindLeftHandSide if you want to. Happy
to help

[Leaf, 2017/08/23 17:26:14]

Not super high priority, but good to fix at some point.

     Expression inc = AstBuilder.binaryExpression(lhs, op, right)
       ..staticElement = element
       ..staticType = getStaticType(lhs);
 
     var castTo = getImplicitOperationCast(left);
     if (castTo != null) inc = CoercionReifier.castExpression(inc, castTo);
     return new JS.MetaLet(vars, [_emitSet(lhs, inc)]);
   }
 
   JS.Expression _emitSet(Expression left, Expression right) {
@@ skipping 763 matching lines @@
   JS.Statement visitVariableDeclarationStatement(
       VariableDeclarationStatement node) {
     // Special case a single variable with an initializer.
     // This helps emit cleaner code for things like:
     //     var result = []..add(1)..add(2);
     var variables = node.variables.variables;
     if (variables.length == 1) {
       var v = variables[0];
       if (v.initializer != null) {
         var name = new JS.Identifier(v.name.name);
-        return _visit<JS.Expression>(v.initializer).toVariableDeclaration(name);
+        var value = _annotatedNullCheck(v.element)
+            ? notNull(v.initializer)
+            : _visit<JS.Expression>(v.initializer);
+        return value.toVariableDeclaration(name);
       }
     }
     return _visit<JS.Expression>(node.variables).toStatement();
   }
 
   @override
   visitVariableDeclarationList(VariableDeclarationList node) {
     return new JS.VariableDeclarationList('let', _visitList(node.variables));
   }
 
@@ skipping 22 matching lines @@
     for (var field in fields) {
       _moduleItems.add(annotate(
           js.statement('# = #;',
               [_emitTopLevelName(field.element), _visitInitializer(field)]),
           field,
           field.element));
     }
   }
 
   JS.Expression _visitInitializer(VariableDeclaration node) {
-    var value = _visit(node.initializer);
+    var value = _annotatedNullCheck(node.element)
+        ? notNull(node.initializer)
+        : _visit(node.initializer);
     // explicitly initialize to null, to avoid getting `undefined`.
     // TODO(jmesserly): do this only for vars that aren't definitely assigned.
     return value ?? new JS.LiteralNull();
   }
 
   JS.Statement _emitLazyFields(
       Element target, List<VariableDeclaration> fields) {
     var methods = [];
     for (var node in fields) {
       var name = node.name.name;
@@ skipping 140 matching lines @@
             : new JS.LiteralNull();
       }
       throw new StateError('failed to evaluate $node');
     }
     return _emitInstanceCreationExpression(
         element, type, name, node.argumentList, node.isConst);
   }
 
   bool isPrimitiveType(DartType t) => typeRep.isPrimitive(t);
 
+  InterfaceType getImplementationType(DartType t) {

[Jennifer Messerly, 2017/08/22 21:54:41]

add a doc comment?

/// Given a Dart type for `bool`, `String`, or `num`/`int`/`double`,
/// returns the corresponding type in `dart:_interceptors`:
/// `JSBool`, `JSString`, and `JSNumber` respectively, otherwise null.

[Leaf, 2017/08/23 17:26:14]

Done.

+    JSType rep = typeRep.typeFor(t);
+    // Number, String, and Bool are final
+    if (rep == JSType.jsNumber) return _jsNumber.type;
+    if (rep == JSType.jsBoolean) return _jsBool.type;
+    if (rep == JSType.jsString) return _jsString.type;
+    return null;
+  }
+
+  JS.Statement nullParameterCheck(JS.Expression param) {
+    var call = _callHelper('throwArgumentErrorValue((#))', [param]);

[Jennifer Messerly, 2017/08/22 21:54:41]

if these are really common, consider a shorter name for the helper?

[Leaf, 2017/08/23 17:26:13]

Done.

+    return js.statement('if (# == null) #;', [param, call]);
+  }
+
   JS.Expression notNull(Expression expr) {
     if (expr == null) return null;
     var jsExpr = _visit(expr);
     if (!isNullable(expr)) return jsExpr;
     return _callHelper('notNull(#)', jsExpr);
   }
 
   JS.Expression _emitEqualityOperator(BinaryExpression node, Token op) {
     var left = node.leftOperand;
     var right = node.rightOperand;
@@ skipping 842 matching lines @@
     return new JS.Do(_visitScope(node.body), _visitTest(node.condition));
   }
 
   @override
   JS.Statement visitForEachStatement(ForEachStatement node) {
     if (node.awaitKeyword != null) {
       return _emitAwaitFor(node);
     }
 
     var init = _visit(node.identifier);
+    var iterable = _visit(node.iterable);
+    var body = _visitScope(node.body);
     if (init == null) {
-      init = js.call('let #', node.loopVariable.identifier.name);
+      var name = node.loopVariable.identifier.name;
+      init = js.call('let #', name);
+      if (_annotatedNullCheck(node.loopVariable.element)) {
+        body =
+            new JS.Block([nullParameterCheck(new JS.Identifier(name)), body]);
+      }
     }
-    return new JS.ForOf(init, _visit(node.iterable), _visitScope(node.body));
+    return new JS.ForOf(init, iterable, body);
   }
 
   JS.Statement _emitAwaitFor(ForEachStatement node) {
     // Emits `await for (var value in stream) ...`, which desugars as:
     //
     // var iter = new StreamIterator(stream);
     // try {
     //   while (await iter.moveNext()) {
     //     var value = iter.current;
     //     ...
@@ skipping 859 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // 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);

[Jennifer Messerly, 2017/08/22 21:54:41]

fyi, parens not necessary

[Leaf, 2017/08/23 17:26:14]

Done.