refactor/simplify nullable inference code

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.
 
 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';
@@ skipping 22 matching lines @@
 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 'nullable_type_inference.dart';
 import 'side_effect_analysis.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';
@@ skipping 50 matching lines @@
   ModuleItemLoadOrder _loader;
 
   /// _interceptors.JSArray<E>, used for List literals.
   ClassElement _jsArray;
 
   /// The default value of the module object. See [visitLibraryDirective].
   String _jsModuleValue;
 
   bool _isDartRuntime;
 
+  NullableTypeInference _nullInference;
+
   JSCodegenVisitor(AbstractCompiler compiler, this.rules, this.currentLibrary,
       this._extensionTypes, this._fieldsNeedingStorage)
       : compiler = compiler,
         options = compiler.options.codegenOptions,
         _types = compiler.context.typeProvider {
     _loader = new ModuleItemLoadOrder(_emitModuleItem);
 
     var context = compiler.context;
     var src = context.sourceFactory.forUri('dart:_interceptors');
     var interceptors = context.computeLibraryElement(src);
     _jsArray = interceptors.getType('JSArray');
     _isDartRuntime = currentLibrary.source.uri.toString() == 'dart:_runtime';
   }
 
   TypeProvider get types => _types;
 
-  NullableExpressionPredicate _isNullable;
-
   JS.Program emitLibrary(LibraryUnit library) {
     // Modify the AST to make coercions explicit.
     new CoercionReifier(library, rules).reify();
 
     // Build the public namespace for this library. This allows us to do
     // constant time lookups (contrast with `Element.getChild(name)`).
     if (currentLibrary.publicNamespace == null) {
       (currentLibrary as LibraryElementImpl).publicNamespace =
           new PublicNamespaceBuilder().build(currentLibrary);
     }
 
     library.library.directives.forEach(_visit);
 
+    var units = library.partsThenLibrary;
+
     // Rather than directly visit declarations, we instead use [_loader] to
     // visit them. It has the ability to sort elements on demand, so
     // dependencies between top level items are handled with a minimal
     // reordering of the user's input code. The loader will call back into
     // this visitor via [_emitModuleItem] when it's ready to visit the item
     // for real.
-    _loader.collectElements(currentLibrary, library.partsThenLibrary);
+    _loader.collectElements(currentLibrary, units);
 
-    var units = library.partsThenLibrary;
-    // TODO(ochafik): Move this down to smaller scopes (method, top-levels) to
-    // save memory.
-    _isNullable = new NullabilityInferrer(units,
-            getStaticType: getStaticType, isJSBuiltinType: _isJSBuiltinType)
-        .buildNullabilityPredicate();
+    // TODO(jmesserly): ideally we could do this at a smaller granularity.
+    // We'll need to be consistent about when we're generating functions, and
+    // only run this on the outermost function.
+    _nullInference =
+        new NullableTypeInference.forLibrary(_isPrimitiveType, units);
+
+    _constField = new ConstFieldVisitor(types, library.library.element.source);
 
     for (var unit in units) {
-      _constField = new ConstFieldVisitor(types, unit);
-
       for (var decl in unit.declarations) {
         if (decl is TopLevelVariableDeclaration) {
           visitTopLevelVariableDeclaration(decl);
         } else {
           _loader.loadDeclaration(decl, decl.element);
         }
       }
     }
 
     // Flush any unwritten fields/properties.
@@ skipping 1065 matching lines @@
 
   /// Initialize fields. They follow the sequence:
   ///
   ///   1. field declaration initializer if non-const,
   ///   2. field initializing parameters,
   ///   3. constructor field initializers,
   ///   4. initialize fields not covered in 1-3
   JS.Statement _initializeFields(
       ClassDeclaration cls, List<FieldDeclaration> fieldDecls,
       [ConstructorDeclaration ctor]) {
-    var unit = cls.getAncestor((a) => a is CompilationUnit) as CompilationUnit;
-    var constField = new ConstFieldVisitor(types, unit);
     bool isConst = ctor != null && ctor.constKeyword != null;
     if (isConst) _loader.startTopLevel(cls.element);
 
     // Run field initializers if they can have side-effects.
     var fields = new Map<FieldElement, JS.Expression>();
     var unsetFields = new Map<FieldElement, VariableDeclaration>();
     for (var declaration in fieldDecls) {
       for (var fieldNode in declaration.fields.variables) {
         var element = fieldNode.element;
-        if (constField.isFieldInitConstant(fieldNode)) {
+        if (_constField.isFieldInitConstant(fieldNode)) {
           unsetFields[element as FieldElement] = fieldNode;
         } else {
           fields[element as FieldElement] = _visitInitializer(fieldNode);
         }
       }
     }
 
     // Initialize fields from `this.fieldName` parameters.
     if (ctor != null) {
       for (var p in ctor.parameters.parameters) {
@@ skipping 340 matching lines @@
       // arrow functions yet (e.g. `({a} = {}) => 1`) but happily accepts them
       // with regular functions (e.g. `function({a} = {}) { return 1 }`).
       // Note that Firefox accepts both syntaxes just fine.
       // TODO(ochafik): Simplify this code when Chrome Canary catches up.
       bool destructureNamed = params.any((p) =>
           p is JS.DestructuredVariable &&
           p.structure is JS.ObjectBindingPattern);
 
       if (body is ExpressionFunctionBody && !destructureNamed) {
         // An arrow function can use the expression directly.
-        // Note: this only works if we don't need to emit argument initializers.
         jsBody = _visit(body.expression);
       } else {
         jsBody = _visit(body);
       }
     }
 
     var fn = new JS.ArrowFun(params, jsBody,
         typeParams: _emitTypeFormals(type.typeFormals),
         returnType: emitTypeRef(type.returnType));
     return annotate(fn, node);
@@ skipping 1007 matching lines @@
     var name = constructor.name;
     var type = constructor.type.type;
     return _emitInstanceCreationExpression(
         element, type, name, node.argumentList, node.isConst);
   }
 
   /// True if this type is built-in to JS, and we use the values unwrapped.
   /// For these types we generate a calling convention via static
   /// "extension methods". This allows types to be extended without adding
   /// extensions directly on the prototype.
-  bool _isJSBuiltinType(DartType t) =>
+  bool _isPrimitiveType(DartType t) =>
       typeIsPrimitiveInJS(t) || t == _types.stringType;
 
   bool typeIsPrimitiveInJS(DartType t) =>
       _isNumberInJS(t) || t == _types.boolType;
 
   bool binaryOperationIsPrimitive(DartType leftT, DartType rightT) =>
       typeIsPrimitiveInJS(leftT) && typeIsPrimitiveInJS(rightT);
 
   bool unaryOperationIsPrimitive(DartType t) => typeIsPrimitiveInJS(t);
 
   JS.Expression notNull(Expression expr) {
     if (expr == null) return null;
     var jsExpr = _visit(expr);
     if (!_isNullable(expr)) return jsExpr;
     return js.call('dart.notNull(#)', jsExpr);
   }
 
+  /// Returns true if [expr] can be null, optionally using [localIsNullable]
+  /// for locals.
+  ///
+  /// This analysis is conservative and incomplete, but it can optimize many
+  /// common patterns.
+  bool _isNullable(Expression expr) => _nullInference.isNullable(expr);
+
   @override
   JS.Expression visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
     var left = node.leftOperand;
     var right = node.rightOperand;
 
     var leftType = getStaticType(left);
     var rightType = getStaticType(right);
 
     var code;
@@ skipping 52 matching lines @@
     var numType = types.numType;
     if (rules.isSubtypeOf(t, numType)) return numType;
     return t;
   }
 
   bool _canUsePrimitiveEquality(Expression left, Expression right) {
     if (_isNull(left) || _isNull(right)) return true;
 
     var leftType = _canonicalizeNumTypes(getStaticType(left));
     var rightType = _canonicalizeNumTypes(getStaticType(right));
-    return _isJSBuiltinType(leftType) && leftType == rightType;
+    return _isPrimitiveType(leftType) && leftType == rightType;
   }
 
   bool _isNull(Expression expr) => expr is NullLiteral;
 
-  SimpleIdentifier _createTemporary(String name, DartType type) {
+  SimpleIdentifier _createTemporary(String name, DartType type,
+      {bool nullable: true}) {
     // We use an invalid source location to signal that this is a temporary.
     // See [_isTemporary].
     // TODO(jmesserly): alternatives are
     // * (ab)use Element.isSynthetic, which isn't currently used for
     //   LocalVariableElementImpl, so we could repurpose to mean "temp".
     // * add a new property to LocalVariableElementImpl.
     // * create a new subtype of LocalVariableElementImpl to mark a temp.
     var id =
         new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, -1));
     id.staticElement = new TemporaryVariableElement.forNode(id);
     id.staticType = type;
     DynamicInvoke.set(id, type.isDynamic);
+    _nullInference.addVariable(id.staticElement, nullable: nullable);
     return id;
   }
 
   JS.Expression _emitConst(JS.Expression expr()) {
     // TODO(jmesserly): emit the constants at top level if possible.
     // This wasn't quite working, so disabled for now.
     return js.call('dart.const(#)', expr());
   }
 
   /// Returns a new expression, which can be be used safely *once* on the
@@ skipping 222 matching lines @@
     var tail = <JS.Expression>[];
     for (;;) {
       var op = _getOperator(node);
       if (op != null && op.lexeme == '?.') {
         var nodeTarget = _getTarget(node);
         if (!_isNullable(nodeTarget)) {
           node = _stripNullAwareOp(node, nodeTarget);
           break;
         }
 
-        var param = _createTemporary('_', nodeTarget.staticType);
+        var param =
+            _createTemporary('_', nodeTarget.staticType, nullable: false);
         var baseNode = _stripNullAwareOp(node, param);
         tail.add(new JS.ArrowFun([_visit(param)], _visit(baseNode)));
         node = nodeTarget;
       } else {
         break;
       }
     }
     if (tail.isEmpty) return _visit(node);
     return js.call('dart.nullSafe(#, #)', [_visit(node), tail.reversed]);
   }
@@ skipping 214 matching lines @@
     var T = node.loopVariable.element.type;
     var StreamIterator_T =
         dart_async.getType('StreamIterator').type.substitute4([T]);
 
     var createStreamIter = _emitInstanceCreationExpression(
         StreamIterator_T.element.unnamedConstructor,
         StreamIterator_T,
         null,
         AstBuilder.argumentList([node.iterable]),
         false);
-    var iter = _visit(_createTemporary('it', StreamIterator_T));
+    var iter =
+        _visit(_createTemporary('it', StreamIterator_T, nullable: false));
 
     var init = _visit(node.identifier);
     if (init == null) {
       init = js
           .call('let # = #.current', [node.loopVariable.identifier.name, iter]);
     } else {
       init = js.call('# = #.current', [init, iter]);
     }
     return js.statement(
         '{'
@@ skipping 395 matching lines @@
   /// 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 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, namedArgumentTemp.name));
     }
     return node..sourceInformation = original;
   }
 
   /// Returns true if this is any kind of object represented by `Number` in JS.
   ///
@@ skipping 152 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);
 }