Version 0.8.10.8

dart/editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/internal/resolver/ResolverVisitor.java

 /*
  * Copyright (c) 2013, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
  * 
  * http://www.eclipse.org/legal/epl-v10.html
  * 
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
@@ skipping 226 matching lines @@
       safelyVisit(leftOperand);
       if (rightOperand != null) {
         try {
           overrideManager.enterScope();
           promoteManager.enterScope();
           propagateTrueState(leftOperand);
           // Type promotion.
           promoteTypes(leftOperand);
           clearTypePromotionsIfPotentiallyMutatedIn(leftOperand);
           clearTypePromotionsIfPotentiallyMutatedIn(rightOperand);
-          clearTypePromotionsIfAccessedInScopeAndProtentiallyMutated(rightOperand);
+          clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(rightOperand);
           // Visit right operand.
           rightOperand.accept(this);
         } finally {
           overrideManager.exitScope();
           promoteManager.exitScope();
         }
       }
     } else if (operatorType == TokenType.BAR_BAR) {
       safelyVisit(leftOperand);
       if (rightOperand != null) {
@@ skipping 99 matching lines @@
     safelyVisit(condition);
     Expression thenExpression = node.getThenExpression();
     if (thenExpression != null) {
       try {
         overrideManager.enterScope();
         promoteManager.enterScope();
         propagateTrueState(condition);
         // Type promotion.
         promoteTypes(condition);
         clearTypePromotionsIfPotentiallyMutatedIn(thenExpression);
-        clearTypePromotionsIfAccessedInScopeAndProtentiallyMutated(thenExpression);
+        clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenExpression);
         // Visit "then" expression.
         thenExpression.accept(this);
       } finally {
         overrideManager.exitScope();
         promoteManager.exitScope();
       }
     }
     Expression elseExpression = node.getElseExpression();
     if (elseExpression != null) {
       try {
@@ skipping 187 matching lines @@
     HashMap<Element, Type> thenOverrides = null;
     Statement thenStatement = node.getThenStatement();
     if (thenStatement != null) {
       try {
         overrideManager.enterScope();
         promoteManager.enterScope();
         propagateTrueState(condition);
         // Type promotion.
         promoteTypes(condition);
         clearTypePromotionsIfPotentiallyMutatedIn(thenStatement);
-        clearTypePromotionsIfAccessedInScopeAndProtentiallyMutated(thenStatement);
+        clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenStatement);
         // Visit "then".
         visitStatementInScope(thenStatement);
       } finally {
         thenOverrides = overrideManager.captureLocalOverrides();
         overrideManager.exitScope();
         promoteManager.exitScope();
       }
     }
     HashMap<Element, Type> elseOverrides = null;
     Statement elseStatement = node.getElseStatement();
@@ skipping 330 matching lines @@
         return;
       }
     }
     Type currentType = getBestType(element);
     if (currentType == null || !currentType.isMoreSpecificThan(potentialType)) {
       overrideManager.setType(element, potentialType);
     }
   }
 
   /**
-   * If it is appropriate to do so, promotes the current type of the static element associated with
-   * the given expression with the given type. Generally speaking, it is appropriate if the given
-   * type is more specific than the current type.
-   * 
-   * @param expression the expression used to access the static element whose types might be
-   *          promoted
-   * @param potentialType the potential type of the elements
-   */
-  protected void promote(Expression expression, Type potentialType) {
-    VariableElement element = getPromotionStaticElement(expression);
-    if (element != null) {
-      // may be mutated somewhere in closure
-      if (((VariableElementImpl) element).isPotentiallyMutatedInClosure()) {
-        return;
-      }
-      // prepare current variable type
-      Type type = expression.getStaticType();
-      // Declared type should not be "dynamic".
-      if (type == null || type.isDynamic()) {
-        return;
-      }
-      // Promoted type should not be "dynamic".
-      if (potentialType == null || potentialType.isDynamic()) {
-        return;
-      }
-      // Promoted type should be more specific than declared.
-      if (!potentialType.isMoreSpecificThan(type)) {
-        return;
-      }
-      // Do promote type of variable.
-      promoteManager.setType(element, potentialType);
-    }
-  }
-
-  /**
    * Report a conditional analysis error with the given error code and arguments.
    * 
    * @param enclosingElement the enclosing element
    * @param errorCode the error code of the error to be reported
    * @param node the node specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   protected void reportErrorProxyConditionalAnalysisError(Element enclosingElement,
       ErrorCode errorCode, ASTNode node, Object... arguments) {
     proxyConditionalAnalysisErrors.add(new ProxyConditionalAnalysisError(
@@ skipping 89 matching lines @@
     // propagateFalseState(condition);
   }
 
   /**
    * Checks each promoted variable in the current scope for compliance with the following
    * specification statement:
    * <p>
    * If the variable <i>v</i> is accessed by a closure in <i>s<sub>1</sub></i> then the variable
    * <i>v</i> is not potentially mutated anywhere in the scope of <i>v</i>.
    */
-  private void clearTypePromotionsIfAccessedInScopeAndProtentiallyMutated(ASTNode target) {
+  private void clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(ASTNode target) {
     for (Element element : promoteManager.getPromotedElements()) {
       if (((VariableElementImpl) element).isPotentiallyMutatedInScope()) {
         if (isVariableAccessedInClosure(element, target)) {
           promoteManager.setType(element, null);
         }
       }
     }
   }
 
   /**
@@ skipping 214 matching lines @@
             result[0] |= true;
           }
         }
         return null;
       }
     });
     return result[0];
   }
 
   /**
+   * If it is appropriate to do so, promotes the current type of the static element associated with
+   * the given expression with the given type. Generally speaking, it is appropriate if the given
+   * type is more specific than the current type.
+   * 
+   * @param expression the expression used to access the static element whose types might be
+   *          promoted
+   * @param potentialType the potential type of the elements
+   */
+  private void promote(Expression expression, Type potentialType) {
+    VariableElement element = getPromotionStaticElement(expression);
+    if (element != null) {
+      // may be mutated somewhere in closure
+      if (((VariableElementImpl) element).isPotentiallyMutatedInClosure()) {
+        return;
+      }
+      // prepare current variable type
+      Type type = promoteManager.getType(element);
+      if (type == null) {
+        type = expression.getStaticType();
+      }
+      // Declared type should not be "dynamic".
+      if (type == null || type.isDynamic()) {
+        return;
+      }
+      // Promoted type should not be "dynamic".
+      if (potentialType == null || potentialType.isDynamic()) {
+        return;
+      }
+      // Promoted type should be more specific than declared.
+      if (!potentialType.isMoreSpecificThan(type)) {
+        return;
+      }
+      // Do promote type of variable.
+      promoteManager.setType(element, potentialType);
+    }
+  }
+
+  /**
    * Promotes type information using given condition.
    */
   private void promoteTypes(Expression condition) {
     if (condition instanceof BinaryExpression) {
       BinaryExpression binary = (BinaryExpression) condition;
       if (binary.getOperator().getType() == TokenType.AMPERSAND_AMPERSAND) {
         Expression left = binary.getLeftOperand();
         Expression right = binary.getRightOperand();
         promoteTypes(left);
         promoteTypes(right);
@@ skipping 80 matching lines @@
    * 
    * @param expression the node whose type is to be recorded
    * @param type the propagated type of the node
    */
   private void recordPropagatedType(Expression expression, Type type) {
     if (type != null && !type.isDynamic()) {
       expression.setPropagatedType(type);
     }
   }
 }