Support type promotion in dart2js.

sdk/lib/_internal/compiler/implementation/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 21 matching lines @@
    * Returns [:true:] if [node] is a type literal.
    *
    * Resolution marks this by setting the type on the node to be the
    * [:Type:] type.
    */
   bool isTypeLiteral(Send node);
 
   /// Register additional dependencies required by [currentElement].
   /// For example, elements that are used by a backend.
   void registerDependency(Element element);
+
+  /// Returns [:true:] if [element] is potentially mutated anywhere in its
+  /// scope.
+  bool isPotentiallyMutated(VariableElement element);
+
+  /// Returns [:true:] if [element] is potentially mutated in [node].
+  bool isPotentiallyMutatedIn(Node node, VariableElement element);
+
+  /// Returns [:true:] if [element] is potentially mutated in a closure.
+  bool isPotentiallyMutatedInClosure(VariableElement element);
+
+  /// Returns [:true:] if [element] is accessed by a closure in [node].
+  bool isAccessedByClosureIn(Node node, VariableElement element);
 }
 
 class TreeElementMapping implements TreeElements {
   final Element currentElement;
   final Map<Spannable, Selector> selectors = new Map<Spannable, Selector>();
   final Map<Node, DartType> types = new Map<Node, DartType>();
   final Set<Node> superUses = new Set<Node>();
   final Set<Element> otherDependencies = new Set<Element>();
   final Map<Node, Constant> constants = new Map<Node, Constant>();
+  final Set<VariableElement> potentiallyMutated = new Set<VariableElement>();
+  final Map<Node, Set<VariableElement>> potentiallyMutatedIn =
+      new Map<Node, Set<VariableElement>>();
+  final Set<VariableElement> potentiallyMutatedInClosure =
+      new Set<VariableElement>();
+  final Map<Node, Set<VariableElement>> accessedByClosureIn =
+      new Map<Node, Set<VariableElement>>();
   final int hashCode = ++hashCodeCounter;
   static int hashCodeCounter = 0;
 
   TreeElementMapping(this.currentElement);
 
   operator []=(Node node, Element element) {
     assert(invariant(node, () {
       FunctionExpression functionExpression = node.asFunctionExpression();
       if (functionExpression != null) {
         return !functionExpression.modifiers.isExternal();
@@ skipping 90 matching lines @@
   }
 
   bool isTypeLiteral(Send node) {
     return getType(node) != null;
   }
 
   void registerDependency(Element element) {
     otherDependencies.add(element.implementation);
   }
 
+  bool isPotentiallyMutated(VariableElement element) {
+    return potentiallyMutated.contains(element);
+  }
+
+  void setPotentiallyMutated(VariableElement element) {
+    potentiallyMutated.add(element);
+  }
+
+  bool isPotentiallyMutatedIn(Node node, VariableElement element) {
+    Set<Element> mutatedIn = potentiallyMutatedIn[node];
+    return mutatedIn != null && mutatedIn.contains(element);
+  }
+
+  void setPotentiallyMutatedIn(Node node, VariableElement element) {
+    potentiallyMutatedIn.putIfAbsent(
+        node, () => new Set<VariableElement>()).add(element);
+  }
+
+  bool isPotentiallyMutatedInClosure(VariableElement element) {
+    return potentiallyMutatedInClosure.contains(element);
+  }
+
+  void setPotentiallyMutatedInClosure(VariableElement element) {
+    potentiallyMutatedInClosure.add(element);
+  }
+
+  bool isAccessedByClosureIn(Node node, VariableElement element) {
+    Set<Element> accessedIn = accessedByClosureIn[node];
+    return accessedIn != null && accessedIn.contains(element);
+  }
+
+  void setAccessedByClosureIn(Node node, VariableElement element) {
+    accessedByClosureIn.putIfAbsent(
+        node, () => new Set<VariableElement>()).add(element);
+  }
+
   String toString() => 'TreeElementMapping($currentElement)';
 }
 
 class ResolverTask extends CompilerTask {
   ResolverTask(Compiler compiler) : super(compiler);
 
   String get name => 'Resolver';
 
   TreeElements resolve(Element element) {
     return measure(() {
@@ skipping 1667 matching lines @@
   bool sendIsMemberAccess = false;
   StatementScope statementScope;
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION
       | ElementCategory.IMPLIES_TYPE;
 
   /// When visiting the type declaration of the variable in a [ForIn] loop,
   /// the initializer of the variable is implicit and we should not emit an
   /// error when verifying that all final variables are initialized.
   bool allowFinalWithoutInitializer = false;
 
+  /// The nodes for which variable access and mutation must be registered in
+  /// order to determine when the static type of variables types is promoted.
+  Link<Node> promotionScope = const Link<Node>();
+
+  bool isPotentiallyMutableTarget(Element target) {
+    if (target == null) return false;
+    return (target.isVariable() || target.isParameter()) &&
+      !(target.modifiers.isFinal() || target.modifiers.isConst());
+  }
+
   // TODO(ahe): Find a way to share this with runtime implementation.
   static final RegExp symbolValidationPattern =
       new RegExp(r'^(?:[a-zA-Z$][a-zA-Z$0-9_]*\.)*(?:[a-zA-Z$][a-zA-Z$0-9_]*=?|'
                  r'-|'
                  r'unary-|'
                  r'\[\]=|'
                  r'~|'
                  r'==|'
                  r'\[\]|'
                  r'\*|'
@@ skipping 78 matching lines @@
   }
 
   inStaticContext(action()) {
     bool wasInstanceContext = inInstanceContext;
     inInstanceContext = false;
     var result = action();
     inInstanceContext = wasInstanceContext;
     return result;
   }
 
+  doInPromotionScope(Node node, action()) {
+    promotionScope = promotionScope.prepend(node);
+    var result = action();
+    promotionScope = promotionScope.tail;
+    return result;
+  }
+
   visitInStaticContext(Node node) {
     inStaticContext(() => visit(node));
   }
 
   ErroneousElement warnAndCreateErroneousElement(Node node,
                                                  SourceString name,
                                                  DualKind kind,
                                                  [Map arguments = const {}]) {
     ResolutionWarning warning = new ResolutionWarning(
         kind.warning, arguments, compiler.terseDiagnostics);
@@ skipping 222 matching lines @@
     statementScope = oldStatementScope;
 
     scope = oldScope;
     enclosingElement = previousEnclosingElement;
 
     world.registerClosure(function, mapping);
     world.registerInstantiatedClass(compiler.functionClass, mapping);
   }
 
   visitIf(If node) {
-    visit(node.condition);
-    visitIn(node.thenPart, new BlockScope(scope));
+    doInPromotionScope(node.condition.expression, () => visit(node.condition));
+    doInPromotionScope(node.thenPart,
+        () => visitIn(node.thenPart, new BlockScope(scope)));
     visitIn(node.elsePart, new BlockScope(scope));
   }
 
   static bool isLogicalOperator(Identifier op) {
     String str = op.source.stringValue;
     return (identical(str, '&&') || str == '||' || str == '!');
   }
 
   Element resolveSend(Send node) {
     Selector selector = resolveSelector(node, null);
@@ skipping 205 matching lines @@
       } else if (!seenNamedArguments.isEmpty) {
         error(argument, MessageKind.INVALID_ARGUMENT_AFTER_NAMED);
       }
     }
     sendIsMemberAccess = oldSendIsMemberAccess;
   }
 
   visitSend(Send node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = node.isPropertyAccess || node.isCall;
-    Element target = resolveSend(node);
+    Element target;
+    if (node.isLogicalAnd) {
+      target = doInPromotionScope(node.receiver, () => resolveSend(node));
+    } else {
+      target = resolveSend(node);
+    }
     sendIsMemberAccess = oldSendIsMemberAccess;
 
     if (target != null
         && target == compiler.mirrorSystemGetNameFunction
         && !compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(enclosingElement)) {
       compiler.reportHint(
           node.selector, MessageKind.STATIC_FUNCTION_BLOAT,
           {'class': compiler.mirrorSystemClass.name,
            'name': compiler.mirrorSystemGetNameFunction.name});
     }
@@ skipping 19 matching lines @@
         world.registerTypeLiteral(target, mapping);
       } else if (target.impliesType() && !sendIsMemberAccess) {
         // Set the type of the node to [Type] to mark this send as a
         // type literal.
         mapping.setType(node, compiler.typeClass.computeType(compiler));
         world.registerTypeLiteral(target, mapping);
 
         // Don't try to make constants of calls to type literals.
         analyzeConstant(node, isConst: !node.isCall);
       }
+      if (isPotentiallyMutableTarget(target)) {
+        if (enclosingElement != target.enclosingElement) {
+          for (Node scope in promotionScope) {
+            mapping.setAccessedByClosureIn(scope, target);
+          }
+        }
+      }
     }
 
     bool resolvedArguments = false;
     if (node.isOperator) {
       String operatorString = node.selector.asOperator().source.stringValue;
       if (identical(operatorString, 'is')) {
+        // TODO(johnniwinther): Use seen type tests to avoid registration of
+        // mutation/access to unpromoted variables.
         DartType type =
             resolveTypeExpression(node.typeAnnotationFromIsCheckOrCast);
         if (type != null) {
           compiler.enqueuer.resolution.registerIsCheck(type, mapping);
         }
         resolvedArguments = true;
       } else if (identical(operatorString, 'as')) {
         DartType type = resolveTypeExpression(node.arguments.head);
         if (type != null) {
           compiler.enqueuer.resolution.registerAsCheck(type, mapping);
         }
         resolvedArguments = true;
+      } else if (identical(operatorString, '&&')) {
+        doInPromotionScope(node.arguments.head,
+            () => resolveArguments(node.argumentsNode));
+        resolvedArguments = true;
       }
     }
 
     if (!resolvedArguments) {
       resolveArguments(node.argumentsNode);
     }
 
     // If the selector is null, it means that we will not be generating
     // code for this as a send.
     Selector selector = mapping.getSelector(node);
@@ skipping 82 matching lines @@
         compiler.backend.registerThrowNoSuchMethod(mapping);
       } else if (target.modifiers.isFinal() ||
                  target.modifiers.isConst() ||
                  (target.isFunction() &&
                      Elements.isStaticOrTopLevelFunction(target) &&
                      !target.isSetter())) {
         setter = warnAndCreateErroneousElement(
             node.selector, target.name, MessageKind.CANNOT_RESOLVE_SETTER);
         compiler.backend.registerThrowNoSuchMethod(mapping);
       }
+      if (isPotentiallyMutableTarget(target)) {
+        mapping.setPotentiallyMutated(target);
+        if (enclosingElement != target.enclosingElement) {
+          mapping.setPotentiallyMutatedInClosure(target);
+        }
+        for (Node scope in promotionScope) {
+          mapping.setPotentiallyMutatedIn(scope, target);
+        }
+      }
     }
 
     visit(node.argumentsNode);
 
     // TODO(ngeoffray): Check if the target can be assigned.
     // TODO(ngeoffray): Warn if target is null and the send is
     // unqualified.
 
     Selector selector = mapping.getSelector(node);
     if (isComplex) {
@@ skipping 410 matching lines @@
     mapping.setType(node, listType);
     world.registerInstantiatedType(listType, mapping);
     compiler.backend.registerRequiredType(listType, enclosingElement);
     visit(node.elements);
     if (node.isConst()) {
       analyzeConstant(node);
     }
   }
 
   visitConditional(Conditional node) {
-    node.visitChildren(this);
+    doInPromotionScope(node.condition, () => visit(node.condition));
+    doInPromotionScope(node.thenExpression, () => visit(node.thenExpression));
+    visit(node.elseExpression);
   }
 
   visitStringInterpolation(StringInterpolation node) {
     world.registerInstantiatedClass(compiler.stringClass, mapping);
     compiler.backend.registerStringInterpolation(mapping);
     node.visitChildren(this);
   }
 
   visitStringInterpolationPart(StringInterpolationPart node) {
     registerImplicitInvocation(const SourceString('toString'), 0);
@@ skipping 1522 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, SourceString name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }