Version 0.4.7.3 .

editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/internal/verifier/ErrorVerifier.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 134 matching lines @@
 
   /**
    * This is set to {@code true} iff the visitor is currently visiting code in the SDK.
    */
   private boolean isInSystemLibrary;
 
   /**
    * The method or function that we are currently visiting, or {@code null} if we are not inside a
    * method or function.
    */
-  private ExecutableElement currentFunction;
+  private ExecutableElement enclosingFunction;
 
   /**
    * This map is initialized when visiting the contents of a class declaration. If the visitor is
    * not in an enclosing class declaration, then the map is set to {@code null}.
    * <p>
    * When set the map maps the set of {@link FieldElement}s in the class to an
    * {@link INIT_STATE#NOT_INIT} or {@link INIT_STATE#INIT_IN_DECLARATION}. <code>checkFor*</code>
    * methods, specifically {@link #checkForAllFinalInitializedErrorCodes(ConstructorDeclaration)},
    * can make a copy of the map to compute error code states. <code>checkFor*</code> methods should
    * only ever make a copy, or read from this map after it has been set in
@@ skipping 87 matching lines @@
   }
 
   @Override
   public Void visitConditionalExpression(ConditionalExpression node) {
     checkForNonBoolCondition(node.getCondition());
     return super.visitConditionalExpression(node);
   }
 
   @Override
   public Void visitConstructorDeclaration(ConstructorDeclaration node) {
-    ExecutableElement previousFunction = currentFunction;
+    ExecutableElement outerFunction = enclosingFunction;
     try {
-      currentFunction = node.getElement();
+      enclosingFunction = node.getElement();
       isEnclosingConstructorConst = node.getConstKeyword() != null;
       checkForConstConstructorWithNonFinalField(node);
       checkForConflictingConstructorNameAndMember(node);
       checkForAllFinalInitializedErrorCodes(node);
       return super.visitConstructorDeclaration(node);
     } finally {
       isEnclosingConstructorConst = false;
-      currentFunction = previousFunction;
+      enclosingFunction = outerFunction;
     }
   }
 
   @Override
   public Void visitDoStatement(DoStatement node) {
     checkForNonBoolCondition(node.getCondition());
     return super.visitDoStatement(node);
   }
 
   @Override
   public Void visitExtendsClause(ExtendsClause node) {
     checkForExtendsDisallowedClass(node);
     return super.visitExtendsClause(node);
   }
 
   @Override
   public Void visitFieldFormalParameter(FieldFormalParameter node) {
     checkForConstFormalParameter(node);
     checkForFieldInitializerOutsideConstructor(node);
     return super.visitFieldFormalParameter(node);
   }
 
   @Override
   public Void visitFunctionDeclaration(FunctionDeclaration node) {
-    ExecutableElement previousFunction = currentFunction;
+    ExecutableElement outerFunction = enclosingFunction;
     try {
-      currentFunction = node.getElement();
+      enclosingFunction = node.getElement();
       return super.visitFunctionDeclaration(node);
     } finally {
-      currentFunction = previousFunction;
+      enclosingFunction = outerFunction;
     }
   }
 
   @Override
   public Void visitFunctionExpression(FunctionExpression node) {
-    ExecutableElement previousFunction = currentFunction;
+    ExecutableElement outerFunction = enclosingFunction;
     try {
-      currentFunction = node.getElement();
+      enclosingFunction = node.getElement();
       return super.visitFunctionExpression(node);
     } finally {
-      currentFunction = previousFunction;
+      enclosingFunction = outerFunction;
     }
   }
 
   @Override
   public Void visitFunctionTypeAlias(FunctionTypeAlias node) {
     checkForBuiltInIdentifierAsName(
         node.getName(),
         CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
     checkForDefaultValueInFunctionTypeAlias(node);
     return super.visitFunctionTypeAlias(node);
@@ skipping 23 matching lines @@
       // TODO(jwren) Email Luke to make this determination: Should we always call all checks, if not,
       // which order should they be called in?
       // (Should we provide as many errors as possible, or try to be as concise as possible?)
       checkForTypeArgumentNotMatchingBounds(node, constructorName.getElement(), typeName);
     }
     return super.visitInstanceCreationExpression(node);
   }
 
   @Override
   public Void visitMethodDeclaration(MethodDeclaration node) {
-    ExecutableElement previousFunction = currentFunction;
+    ExecutableElement previousFunction = enclosingFunction;
     try {
-      currentFunction = node.getElement();
+      enclosingFunction = node.getElement();
       return super.visitMethodDeclaration(node);
     } finally {
-      currentFunction = previousFunction;
+      enclosingFunction = previousFunction;
     }
   }
 
   @Override
   public Void visitNativeFunctionBody(NativeFunctionBody node) {
     checkForNativeFunctionBodyInNonSDKCode(node);
     return super.visitNativeFunctionBody(node);
   }
 
   @Override
@@ skipping 697 matching lines @@
 
   /**
    * This checks that the return type matches the type of the declared return type in the enclosing
    * method or function.
    * 
    * @param node the return statement to evaluate
    * @return return {@code true} if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#RETURN_OF_INVALID_TYPE
    */
   private boolean checkForReturnOfInvalidType(ReturnStatement node) {
-    FunctionType functionType = currentFunction == null ? null : currentFunction.getType();
+    FunctionType functionType = enclosingFunction == null ? null : enclosingFunction.getType();
     Type expectedReturnType = functionType == null ? null : functionType.getReturnType();
     Expression returnExpression = node.getExpression();
     if (expectedReturnType != null && !expectedReturnType.isVoid() && returnExpression != null) {
       Type actualReturnType = getType(returnExpression);
       if (!actualReturnType.isAssignableTo(expectedReturnType)) {
         errorReporter.reportError(
             StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
             returnExpression,
             actualReturnType.getName(),
             expectedReturnType.getName(),
-            currentFunction.getName());
+            enclosingFunction.getName());
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the type arguments in the passed instance creation expression are all within
    * their bounds as specified by the class element where the constructor [that is being invoked] is
    * declared.
@@ skipping 53 matching lines @@
   private VariableElement getVariableElement(Expression expression) {
     if (expression instanceof Identifier) {
       Element element = ((Identifier) expression).getElement();
       if (element instanceof VariableElement) {
         return (VariableElement) element;
       }
     }
     return null;
   }
 }