Add a few more known non-null cases

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 38 matching lines @@
 // 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';
 const DSEND = 'dsend';
 
 class JSCodegenVisitor extends GeneralizingAstVisitor
-    with ClosureAnnotator, JsTypeRefCodegen {
+    with ClosureAnnotator, JsTypeRefCodegen, NullableTypeInference {
   final AbstractCompiler compiler;
   final CodegenOptions options;
   final LibraryElement currentLibrary;
   final StrongTypeSystemImpl rules;
 
   /// The global extension type table.
   final ExtensionTypeSet _extensionTypes;
 
   /// Information that is precomputed for this library, indicates which fields
   /// need storage slots.
@@ skipping 34 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);
@@ skipping 22 matching lines @@
     // 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, units);
 
     // 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);
+    inferNullableTypesInLibrary(units);
 
     _constField = new ConstFieldVisitor(types, library.library.element.source);
 
     for (var unit in units) {
       for (var decl in unit.declarations) {
         if (decl is TopLevelVariableDeclaration) {
           visitTopLevelVariableDeclaration(decl);
         } else {
           _loader.loadDeclaration(decl, decl.element);
         }
@@ skipping 2463 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 _isPrimitiveType(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;
+    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;
     if (op.type.isEqualityOperator) {
       // If we statically know LHS or RHS is null we can generate a clean check.
       // We can also do this if both sides are the same primitive type.
       if (_canUsePrimitiveEquality(left, right)) {
         code = op.type == TokenType.EQ_EQ ? '# == #' : '# != #';
       } else if (left is SuperExpression) {
         return _emitSend(left, op.lexeme, [right]);
       } else {
         var bang = op.type == TokenType.BANG_EQ ? '!' : '';
         code = '${bang}dart.equals(#, #)';
       }
       return js.call(code, [_visit(left), _visit(right)]);
     }
 
     if (op.type.lexeme == '??') {
       // TODO(jmesserly): leave RHS for debugging?
       // This should be a hint or warning for dead code.
-      if (!_isNullable(left)) return _visit(left);
+      if (!isNullable(left)) return _visit(left);
 
       var vars = <String, JS.Expression>{};
       // Desugar `l ?? r` as `l != null ? l : r`
       var l = _visit(_bindValue(vars, 'l', left, context: left));
       return new JS.MetaLet(vars, [
         js.call('# != null ? # : #', [l, l, _visit(right)])
       ]);
     }
 
     if (binaryOperationIsPrimitive(leftType, rightType) ||
@@ skipping 24 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 _isPrimitiveType(leftType) && leftType == rightType;
+    return isPrimitiveType(leftType) && leftType == rightType;
   }
 
   bool _isNull(Expression expr) => expr is NullLiteral;
 
   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);
+    addTemporaryVariable(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 86 matching lines @@
   ///
   /// The [JS.MetaLet] nodes automatically simplify themselves if they can.
   /// For example, if the result value is not used, then `t` goes away.
   @override
   JS.Expression visitPostfixExpression(PostfixExpression node) {
     var op = node.operator;
     var expr = node.operand;
 
     var dispatchType = getStaticType(expr);
     if (unaryOperationIsPrimitive(dispatchType)) {
-      if (!_isNullable(expr)) {
+      if (!isNullable(expr)) {
         return js.call('#$op', _visit(expr));
       }
     }
 
     assert(op.lexeme == '++' || op.lexeme == '--');
 
     // Handle the left hand side, to ensure each of its subexpressions are
     // evaluated only once.
     var vars = <String, JS.Expression>{};
     var left = _bindLeftHandSide(vars, expr, context: expr);
@@ skipping 11 matching lines @@
     return new JS.MetaLet(vars, body, statelessResult: true);
   }
 
   @override
   JS.Expression visitPrefixExpression(PrefixExpression node) {
     var op = node.operator;
     var expr = node.operand;
 
     var dispatchType = getStaticType(expr);
     if (unaryOperationIsPrimitive(dispatchType)) {
-      if (!_isNullable(expr)) {
+      if (!isNullable(expr)) {
         return js.call('$op#', _visit(expr));
       } else if (op.lexeme == '++' || op.lexeme == '--') {
         // We need a null check, so the increment must be expanded out.
         var vars = <String, JS.Expression>{};
         var x = _bindLeftHandSide(vars, expr, context: expr);
 
         var one = AstBuilder.integerLiteral(1)..staticType = types.intType;
         var increment = AstBuilder.binaryExpression(x, op.lexeme[0], one)
           ..staticElement = node.staticElement
           ..staticType = getStaticType(expr);
@@ skipping 78 matching lines @@
     // This pattern has the benefit of preserving order, as well as minimizing
     // code expansion: each `?.` becomes `, _ => _`, plus one helper call.
     //
     // TODO(jmesserly): we could desugar with MetaLet instead, which may
     // lead to higher performing code, but at the cost of readability.
     var tail = <JS.Expression>[];
     for (;;) {
       var op = _getOperator(node);
       if (op != null && op.lexeme == '?.') {
         var nodeTarget = _getTarget(node);
-        if (!_isNullable(nodeTarget)) {
+        if (!isNullable(nodeTarget)) {
           node = _stripNullAwareOp(node, nodeTarget);
           break;
         }
 
         var param =
             _createTemporary('_', nodeTarget.staticType, nullable: false);
         var baseNode = _stripNullAwareOp(node, param);
         tail.add(new JS.ArrowFun([_visit(param)], _visit(baseNode)));
         node = nodeTarget;
       } else {
@@ skipping 16 matching lines @@
       return AstBuilder.propertyAccess(newTarget, node.propertyName);
     } else {
       var invoke = node as MethodInvocation;
       return AstBuilder.methodInvoke(
           newTarget, invoke.methodName, invoke.argumentList.arguments);
     }
   }
 
   bool _requiresStaticDispatch(Expression target, String memberName) {
     var type = getStaticType(target);
-    if (!_isObjectProperty(memberName)) {
+    if (!isObjectProperty(memberName)) {
       return false;
     }
 
     // If the target could be `null`, we need static dispatch.
     // If the target may be an extension type, we also use static dispatch
     // as we don't symbolize object properties like hashCode.
-    return _isNullable(target) ||
+    return isNullable(target) ||
         (_extensionTypes.contains(type.element) && target is! SuperExpression);
   }
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
   JS.Expression _emitGet(Expression target, SimpleIdentifier memberId) {
     var member = memberId.staticElement;
     if (member is PropertyAccessorElement) {
       member = (member as PropertyAccessorElement).variable;
     }
     bool isStatic = member is ClassMemberElement && member.isStatic;
@@ skipping 570 matching lines @@
     }
 
     // Dart "extension" methods. Used for JS Array, Boolean, Number, String.
     var baseType = type;
     while (baseType is TypeParameterType) {
       baseType = baseType.element.bound;
     }
     if (allowExtensions &&
         baseType != null &&
         _extensionTypes.contains(baseType.element) &&
-        !_isObjectProperty(name)) {
+        !isObjectProperty(name)) {
       return js.call('dartx.#', _propertyName(name));
     }
 
     return _propertyName(name);
   }
 
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
   FunctionBody _functionBody(node) =>
@@ skipping 28 matching lines @@
   bool _isObjectGetter(String name) {
     PropertyAccessorElement element = _types.objectType.element.getGetter(name);
     return (element != null && !element.isStatic);
   }
 
   bool _isObjectMethod(String name) {
     MethodElement element = _types.objectType.element.getMethod(name);
     return (element != null && !element.isStatic);
   }
 
-  bool _isObjectProperty(String name) {
+  bool isObjectProperty(String name) {
     return _isObjectGetter(name) || _isObjectMethod(name);
   }
 
   // TODO(leafp): Various analyzer pieces computed similar things.
   // Share this logic somewhere?
   DartType _getExpectedReturnType(ExecutableElement element) {
     FunctionType functionType = element.type;
     if (functionType == null) {
       return DynamicTypeImpl.instance;
     }
@@ skipping 169 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);
 }