New analyzer snapshot (with CaughtException).

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.resolver;
 
 import 'dart:collection';
@@ skipping 1443 matching lines @@
             invalidKeys.add(key);
           } else {
             keys.add(value);
           }
           DartType type = value.type;
           if (_implementsEqualsWhenNotAllowed(type)) {
             _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, key, [type.displayName]);
           }
         }
       } else {
-        EvaluationResultImpl result = key.accept(new ConstantVisitor(_typeProvider));
+        EvaluationResultImpl result = key.accept(new ConstantVisitor.con1(_typeProvider));
         if (result is ValidResult) {
           DartObject value = result.value;
           if (keys.contains(value)) {
             invalidKeys.add(key);
           } else {
             keys.add(value);
           }
         } else {
           reportEqualKeys = false;
         }
@@ skipping 164 matching lines @@
 
   /**
    * Validate that the given expression is a compile time constant. Return the value of the compile
    * time constant, or `null` if the expression is not a compile time constant.
    *
    * @param expression the expression to be validated
    * @param errorCode the error code to be used if the expression is not a compile time constant
    * @return the value of the compile time constant
    */
   EvaluationResultImpl _validate(Expression expression, ErrorCode errorCode) {
-    EvaluationResultImpl result = expression.accept(new ConstantVisitor(_typeProvider));
+    EvaluationResultImpl result = expression.accept(new ConstantVisitor.con1(_typeProvider));
     _reportErrors(result, errorCode);
     return result;
   }
 
   /**
    * Validate that if the passed arguments are constant expressions.
    *
    * @param argumentList the argument list to evaluate
    */
   void _validateConstantArguments(ArgumentList argumentList) {
@@ skipping 103 matching lines @@
     }
     _validateConstantArguments(argumentList);
   }
 }
 
 class ConstantVisitor_ConstantVerifier_validateInitializerExpression extends ConstantVisitor {
   final ConstantVerifier ConstantVerifier_this;
 
   List<ParameterElement> parameterElements;
 
-  ConstantVisitor_ConstantVerifier_validateInitializerExpression(TypeProvider arg0, this.ConstantVerifier_this, this.parameterElements) : super(arg0);
+  ConstantVisitor_ConstantVerifier_validateInitializerExpression(TypeProvider arg0, this.ConstantVerifier_this, this.parameterElements) : super.con1(arg0);
 
   @override
   EvaluationResultImpl visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     for (ParameterElement parameterElement in parameterElements) {
       if (identical(parameterElement, element) && parameterElement != null) {
         DartType type = parameterElement.type;
         if (type != null) {
           if (type.isDynamic) {
             return ConstantVerifier_this._valid(ConstantVerifier_this._typeProvider.objectType, DynamicState.DYNAMIC_STATE);
@@ skipping 3362 matching lines @@
         targetTypeName = targetType == null ? null : targetType.displayName;
         ErrorCode proxyErrorCode = (generatedWithTypePropagation ? HintCode.UNDEFINED_METHOD : StaticTypeWarningCode.UNDEFINED_METHOD);
         if (_doesClassElementHaveProxy(targetType.element)) {
           _resolver.reportErrorForNode(proxyErrorCode, methodName, [methodName.name, targetTypeName]);
         }
       }
     } else if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_SUPER_METHOD)) {
       // Generate the type name.
       // The error code will never be generated via type propagation
       DartType targetType = _getStaticType(target);
+      if (targetType is InterfaceType && !targetType.isObject) {
+        targetType = (targetType as InterfaceType).superclass;
+      }
       String targetTypeName = targetType == null ? null : targetType.name;
       _resolver.reportErrorForNode(StaticTypeWarningCode.UNDEFINED_SUPER_METHOD, methodName, [methodName.name, targetTypeName]);
     }
     return null;
   }
 
   @override
   Object visitPartDirective(PartDirective node) {
     _setMetadata(node.element, node);
     return null;
@@ skipping 2090 matching lines @@
     return super.visitAnnotation(node);
   }
 
   @override
   Object visitArgumentList(ArgumentList node) {
     _checkForArgumentTypesNotAssignableInList(node);
     return super.visitArgumentList(node);
   }
 
   @override
+  Object visitAsExpression(AsExpression node) {
+    _checkForTypeAnnotationDeferredClass(node.type);
+    return super.visitAsExpression(node);
+  }
+
+  @override
   Object visitAssertStatement(AssertStatement node) {
     _checkForNonBoolExpression(node);
     return super.visitAssertStatement(node);
   }
 
   @override
   Object visitAssignmentExpression(AssignmentExpression node) {
     sc.TokenType operatorType = node.operator.type;
     Expression lhs = node.leftHandSide;
     Expression rhs = node.rightHandSide;
     if (operatorType == sc.TokenType.EQ) {
       _checkForInvalidAssignment(lhs, rhs);
     } else {
       _checkForInvalidCompoundAssignment(node, lhs, rhs);
     }
     _checkForAssignmentToFinal(lhs);
     _checkForArgumentTypeNotAssignableForArgument(rhs);
     return super.visitAssignmentExpression(node);
   }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
-    _checkForArgumentTypeNotAssignableForArgument(node.rightOperand);
+    sc.Token operator = node.operator;
+    sc.TokenType type = operator.type;
+    if (type == sc.TokenType.AMPERSAND_AMPERSAND || type == sc.TokenType.BAR_BAR) {
+      String lexeme = operator.lexeme;
+      _checkForAssignability(node.leftOperand, _boolType, StaticTypeWarningCode.NON_BOOL_OPERAND, [lexeme]);
+      _checkForAssignability(node.rightOperand, _boolType, StaticTypeWarningCode.NON_BOOL_OPERAND, [lexeme]);
+    } else {
+      _checkForArgumentTypeNotAssignableForArgument(node.rightOperand);
+    }
     return super.visitBinaryExpression(node);
   }
 
   @override
   Object visitBlockFunctionBody(BlockFunctionBody node) {
     bool previousHasReturnWithoutValue = _hasReturnWithoutValue;
     _hasReturnWithoutValue = false;
     List<ReturnStatement> previousReturnsWith = _returnsWith;
     List<ReturnStatement> previousReturnsWithout = _returnsWithout;
     try {
@@ skipping 19 matching lines @@
       }
     }
     return null;
   }
 
   @override
   Object visitCatchClause(CatchClause node) {
     bool previousIsInCatchClause = _isInCatchClause;
     try {
       _isInCatchClause = true;
+      _checkForTypeAnnotationDeferredClass(node.exceptionType);
       return super.visitCatchClause(node);
     } finally {
       _isInCatchClause = previousIsInCatchClause;
     }
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
@@ skipping 318 matching lines @@
           _checkForNewWithUndefinedConstructor(node, constructorName, typeName);
         }
       }
       return super.visitInstanceCreationExpression(node);
     } finally {
       _isInConstInstanceCreation = false;
     }
   }
 
   @override
+  Object visitIsExpression(IsExpression node) {
+    _checkForTypeAnnotationDeferredClass(node.type);
+    return super.visitIsExpression(node);
+  }
+
+  @override
   Object visitListLiteral(ListLiteral node) {
     TypeArgumentList typeArguments = node.typeArguments;
     if (typeArguments != null) {
       if (node.constKeyword != null) {
         NodeList<TypeName> arguments = typeArguments.arguments;
         if (arguments.length != 0) {
           _checkForInvalidTypeArgumentInConstTypedLiteral(arguments, CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST);
         }
       }
       _checkForExpectedOneListTypeArgument(node, typeArguments);
@@ skipping 1006 matching lines @@
       return false;
     }
     bool problemReported = false;
     for (Expression argument in argumentList.arguments) {
       problemReported = javaBooleanOr(problemReported, _checkForArgumentTypeNotAssignableForArgument(argument));
     }
     return problemReported;
   }
 
   /**
+   * Check that the static type of the given expression is assignable to the given type. If it
+   * isn't, report an error with the given error code.
+   *
+   * @param expression the expression being tested
+   * @param type the type that the expression must be assignable to
+   * @param errorCode the error code to be reported
+   * @param arguments the arguments to pass in when creating the error
+   * @return `true` if an error was reported
+   */
+  bool _checkForAssignability(Expression expression, InterfaceType type, ErrorCode errorCode, List<Object> arguments) {
+    if (expression == null) {
+      return false;
+    }
+    DartType expressionType = expression.staticType;
+    if (expressionType == null) {
+      return false;
+    }
+    if (expressionType.isAssignableTo(type)) {
+      return false;
+    }
+    _errorReporter.reportErrorForNode(errorCode, expression, arguments);
+    return true;
+  }
+
+  /**
    * This verifies that the passed expression is not final.
    *
    * @param node the expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ASSIGNMENT_TO_CONST
    * @see StaticWarningCode#ASSIGNMENT_TO_FINAL
    * @see StaticWarningCode#ASSIGNMENT_TO_METHOD
    */
   bool _checkForAssignmentToFinal(Expression expression) {
     // prepare element
@@ skipping 14 matching lines @@
       PropertyAccessorElement accessor = element as PropertyAccessorElement;
       element = accessor.variable;
     }
     if (element is VariableElement) {
       VariableElement variable = element as VariableElement;
       if (variable.isConst) {
         _errorReporter.reportErrorForNode(StaticWarningCode.ASSIGNMENT_TO_CONST, expression, []);
         return true;
       }
       if (variable.isFinal) {
+        if (variable is FieldElementImpl && variable.setter == null && variable.isSynthetic) {
+          _errorReporter.reportErrorForNode(StaticWarningCode.ASSIGNMENT_TO_FINAL_NO_SETTER, highlightedNode, [variable.name, variable.enclosingElement.displayName]);
+          return true;
+        }
         _errorReporter.reportErrorForNode(StaticWarningCode.ASSIGNMENT_TO_FINAL, highlightedNode, [variable.name]);
         return true;
       }
       return false;
     }
     if (element is FunctionElement) {
       _errorReporter.reportErrorForNode(StaticWarningCode.ASSIGNMENT_TO_FUNCTION, expression, []);
       return true;
     }
     if (element is MethodElement) {
@@ skipping 469 matching lines @@
    * @see CompileTimeErrorCode#CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER
    */
   bool _checkForConstConstructorWithNonConstSuper(ConstructorDeclaration node) {
     if (!_isEnclosingConstructorConst) {
       return false;
     }
     // OK, const factory, checked elsewhere
     if (node.factoryKeyword != null) {
       return false;
     }
+    // check for mixins
+    if (_enclosingClass.mixins.length != 0) {
+      _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_MIXIN, node.returnType, []);
+      return true;
+    }
     // try to find and check super constructor invocation
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation superInvocation = initializer;
         ConstructorElement element = superInvocation.staticElement;
         if (element == null || element.isConst) {
           return false;
         }
-        _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER, superInvocation, []);
+        _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER, superInvocation, [element.enclosingElement.displayName]);
         return true;
       }
     }
     // no explicit super constructor invocation, check default constructor
     InterfaceType supertype = _enclosingClass.supertype;
     if (supertype == null) {
       return false;
     }
     if (supertype.isObject) {
       return false;
     }
     ConstructorElement unnamedConstructor = supertype.element.unnamedConstructor;
     if (unnamedConstructor == null) {
       return false;
     }
     if (unnamedConstructor.isConst) {
       return false;
     }
     // default constructor is not 'const', report problem
-    _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER, node.returnType, []);
+    _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER, node.returnType, [supertype.displayName]);
     return true;
   }
 
   /**
    * This verifies that if the passed constructor declaration is 'const' then there are no non-final
    * instance variable.
    *
    * @param node the constructor declaration to evaluate
    * @param constructorElement the constructor element
    * @return `true` if and only if an error code is generated on the passed node
@@ skipping 2744 matching lines @@
   /**
    * Set to `true` when a `break` is encountered, and reset to `false` when a
    * `do`, `while`, `for` or `switch` block is entered.
    */
   bool _enclosingBlockContainsBreak = false;
 
   @override
   bool visitArgumentList(ArgumentList node) => _visitExpressions(node.arguments);
 
   @override
-  bool visitAsExpression(AsExpression node) => node.expression.accept(this);
+  bool visitAsExpression(AsExpression node) => _nodeExits(node.expression);
 
   @override
-  bool visitAssertStatement(AssertStatement node) => node.condition.accept(this);
+  bool visitAssertStatement(AssertStatement node) => _nodeExits(node.condition);
 
   @override
-  bool visitAssignmentExpression(AssignmentExpression node) => node.leftHandSide.accept(this) || node.rightHandSide.accept(this);
+  bool visitAssignmentExpression(AssignmentExpression node) => _nodeExits(node.leftHandSide) || _nodeExits(node.rightHandSide);
 
   @override
   bool visitBinaryExpression(BinaryExpression node) {
     Expression lhsExpression = node.leftOperand;
     sc.TokenType operatorType = node.operator.type;
     // If the operator is || and the left hand side is false literal, don't consider the RHS of the
     // binary expression.
     // TODO(jwren) Do we want to take constant expressions into account, evaluate if(false) {}
     // differently than if(<condition>), when <condition> evaluates to a constant false value?
     if (operatorType == sc.TokenType.BAR_BAR) {
       if (lhsExpression is BooleanLiteral) {
         BooleanLiteral booleanLiteral = lhsExpression;
         if (!booleanLiteral.value) {
           return false;
         }
       }
     }
     // If the operator is && and the left hand side is true literal, don't consider the RHS of the
     // binary expression.
     if (operatorType == sc.TokenType.AMPERSAND_AMPERSAND) {
       if (lhsExpression is BooleanLiteral) {
         BooleanLiteral booleanLiteral = lhsExpression;
         if (booleanLiteral.value) {
           return false;
         }
       }
     }
     Expression rhsExpression = node.rightOperand;
-    return (lhsExpression != null && lhsExpression.accept(this)) || (rhsExpression != null && rhsExpression.accept(this));
+    return _nodeExits(lhsExpression) || _nodeExits(rhsExpression);
   }
 
   @override
   bool visitBlock(Block node) => _visitStatements(node.statements);
 
   @override
-  bool visitBlockFunctionBody(BlockFunctionBody node) => node.block.accept(this);
+  bool visitBlockFunctionBody(BlockFunctionBody node) => _nodeExits(node.block);
 
   @override
   bool visitBreakStatement(BreakStatement node) {
     _enclosingBlockContainsBreak = true;
     return false;
   }
 
   @override
-  bool visitCascadeExpression(CascadeExpression node) {
-    Expression target = node.target;
-    if (target.accept(this)) {
-      return true;
-    }
-    return _visitExpressions(node.cascadeSections);
-  }
+  bool visitCascadeExpression(CascadeExpression node) => _nodeExits(node.target) || _visitExpressions(node.cascadeSections);
 
   @override
   bool visitConditionalExpression(ConditionalExpression node) {
     Expression conditionExpression = node.condition;
     Expression thenStatement = node.thenExpression;
     Expression elseStatement = node.elseExpression;
     // TODO(jwren) Do we want to take constant expressions into account, evaluate if(false) {}
     // differently than if(<condition>), when <condition> evaluates to a constant false value?
-    if (conditionExpression.accept(this)) {
+    if (_nodeExits(conditionExpression)) {
       return true;
     }
     if (thenStatement == null || elseStatement == null) {
       return false;
     }
     return thenStatement.accept(this) && elseStatement.accept(this);
   }
 
   @override
   bool visitContinueStatement(ContinueStatement node) => false;
 
   @override
   bool visitDoStatement(DoStatement node) {
     bool outerBreakValue = _enclosingBlockContainsBreak;
     _enclosingBlockContainsBreak = false;
     try {
       Expression conditionExpression = node.condition;
-      if (conditionExpression.accept(this)) {
+      if (_nodeExits(conditionExpression)) {
         return true;
       }
       // TODO(jwren) Do we want to take all constant expressions into account?
       if (conditionExpression is BooleanLiteral) {
         BooleanLiteral booleanLiteral = conditionExpression;
         // If do {} while (true), and the body doesn't return or the body doesn't have a break, then
         // return true.
-        bool blockReturns = node.body.accept(this);
+        bool blockReturns = _nodeExits(node.body);
         if (booleanLiteral.value && (blockReturns || !_enclosingBlockContainsBreak)) {
           return true;
         }
       }
       return false;
     } finally {
       _enclosingBlockContainsBreak = outerBreakValue;
     }
   }
 
   @override
   bool visitEmptyStatement(EmptyStatement node) => false;
 
   @override
-  bool visitExpressionStatement(ExpressionStatement node) => node.expression.accept(this);
+  bool visitExpressionStatement(ExpressionStatement node) => _nodeExits(node.expression);
 
   @override
   bool visitForEachStatement(ForEachStatement node) {
     bool outerBreakValue = _enclosingBlockContainsBreak;
     _enclosingBlockContainsBreak = false;
     try {
-      return node.iterator.accept(this);
+      return _nodeExits(node.iterator);
     } finally {
       _enclosingBlockContainsBreak = outerBreakValue;
     }
   }
 
   @override
   bool visitForStatement(ForStatement node) {
     bool outerBreakValue = _enclosingBlockContainsBreak;
     _enclosingBlockContainsBreak = false;
     try {
       if (node.variables != null && _visitVariableDeclarations(node.variables.variables)) {
         return true;
       }
-      if (node.initialization != null && node.initialization.accept(this)) {
+      if (node.initialization != null && _nodeExits(node.initialization)) {
         return true;
       }
       Expression conditionExpression = node.condition;
-      if (conditionExpression != null && conditionExpression.accept(this)) {
+      if (conditionExpression != null && _nodeExits(conditionExpression)) {
         return true;
       }
       if (_visitExpressions(node.updaters)) {
         return true;
       }
       // TODO(jwren) Do we want to take all constant expressions into account?
       // If for(; true; ) (or for(;;)), and the body doesn't return or the body doesn't have a
       // break, then return true.
       bool implicitOrExplictTrue = conditionExpression == null || (conditionExpression is BooleanLiteral && conditionExpression.value);
       if (implicitOrExplictTrue) {
-        bool blockReturns = node.body.accept(this);
+        bool blockReturns = _nodeExits(node.body);
         if (blockReturns || !_enclosingBlockContainsBreak) {
           return true;
         }
       }
       return false;
     } finally {
       _enclosingBlockContainsBreak = outerBreakValue;
     }
   }
 
   @override
   bool visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => false;
 
   @override
   bool visitFunctionExpression(FunctionExpression node) => false;
 
   @override
   bool visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
-    if (node.function.accept(this)) {
+    if (_nodeExits(node.function)) {
       return true;
     }
     return node.argumentList.accept(this);
   }
 
   @override
   bool visitIdentifier(Identifier node) => false;
 
   @override
   bool visitIfStatement(IfStatement node) {
     Expression conditionExpression = node.condition;
     Statement thenStatement = node.thenStatement;
     Statement elseStatement = node.elseStatement;
-    if (conditionExpression.accept(this)) {
+    if (_nodeExits(conditionExpression)) {
       return true;
     }
     // TODO(jwren) Do we want to take all constant expressions into account?
     if (conditionExpression is BooleanLiteral) {
       BooleanLiteral booleanLiteral = conditionExpression;
       if (booleanLiteral.value) {
         // if(true) ...
-        return thenStatement.accept(this);
+        return _nodeExits(thenStatement);
       } else if (elseStatement != null) {
         // if (false) ...
-        return elseStatement.accept(this);
+        return _nodeExits(elseStatement);
       }
     }
     if (thenStatement == null || elseStatement == null) {
       return false;
     }
-    return thenStatement.accept(this) && elseStatement.accept(this);
+    return _nodeExits(thenStatement) && _nodeExits(elseStatement);
   }
 
   @override
   bool visitIndexExpression(IndexExpression node) {
     Expression target = node.realTarget;
-    if (target != null && target.accept(this)) {
+    if (_nodeExits(target)) {
       return true;
     }
-    if (node.index.accept(this)) {
+    if (_nodeExits(node.index)) {
       return true;
     }
     return false;
   }
 
   @override
-  bool visitInstanceCreationExpression(InstanceCreationExpression node) => node.argumentList.accept(this);
+  bool visitInstanceCreationExpression(InstanceCreationExpression node) => _nodeExits(node.argumentList);
 
   @override
   bool visitIsExpression(IsExpression node) => node.expression.accept(this);
 
   @override
   bool visitLabel(Label node) => false;
 
   @override
   bool visitLabeledStatement(LabeledStatement node) => node.statement.accept(this);
 
   @override
   bool visitLiteral(Literal node) => false;
 
   @override
   bool visitMethodInvocation(MethodInvocation node) {
     Expression target = node.realTarget;
     if (target != null && target.accept(this)) {
       return true;
     }
-    return node.argumentList.accept(this);
+    return _nodeExits(node.argumentList);
   }
 
   @override
   bool visitNamedExpression(NamedExpression node) => node.expression.accept(this);
 
   @override
   bool visitParenthesizedExpression(ParenthesizedExpression node) => node.expression.accept(this);
 
   @override
   bool visitPostfixExpression(PostfixExpression node) => false;
@@ skipping 55 matching lines @@
   }
 
   @override
   bool visitThisExpression(ThisExpression node) => false;
 
   @override
   bool visitThrowExpression(ThrowExpression node) => true;
 
   @override
   bool visitTryStatement(TryStatement node) {
-    if (node.body.accept(this)) {
+    if (_nodeExits(node.body)) {
       return true;
     }
     Block finallyBlock = node.finallyBlock;
-    if (finallyBlock != null && finallyBlock.accept(this)) {
+    if (_nodeExits(finallyBlock)) {
       return true;
     }
     return false;
   }
 
   @override
   bool visitTypeName(TypeName node) => false;
 
   @override
   bool visitVariableDeclaration(VariableDeclaration node) {
@@ skipping 36 matching lines @@
         if (booleanLiteral.value && (blockReturns || !_enclosingBlockContainsBreak)) {
           return true;
         }
       }
       return false;
     } finally {
       _enclosingBlockContainsBreak = outerBreakValue;
     }
   }
 
+  /**
+   * Return `true` if the given node exits.
+   *
+   * @param node the node being tested
+   * @return `true` if the given node exits
+   */
+  bool _nodeExits(AstNode node) {
+    if (node == null) {
+      return false;
+    }
+    return node.accept(this);
+  }
+
   bool _visitExpressions(NodeList<Expression> expressions) {
     for (int i = expressions.length - 1; i >= 0; i--) {
       if (expressions[i].accept(this)) {
         return true;
       }
     }
     return false;
   }
 
   bool _visitStatements(NodeList<Statement> statements) {
@@ skipping 387 matching lines @@
       ht.XmlAttributeNode scriptAttribute = _getScriptSourcePath(node);
       String scriptSourcePath = scriptAttribute == null ? null : scriptAttribute.text;
       if (node.attributeEnd.type == ht.TokenType.GT && scriptSourcePath == null) {
         EmbeddedHtmlScriptElementImpl script = new EmbeddedHtmlScriptElementImpl(node);
         try {
           LibraryResolver resolver = new LibraryResolver(_context);
           LibraryElementImpl library = resolver.resolveEmbeddedLibrary(htmlSource, _modificationStamp, node.script, true) as LibraryElementImpl;
           script.scriptLibrary = library;
           _resolvedLibraries.addAll(resolver.resolvedLibraries);
           _errorListener.addAll(resolver.errorListener);
-        } on AnalysisException catch (exception) {
+        } on AnalysisException catch (exception, stackTrace) {
           //TODO (danrubel): Handle or forward the exception
-          AnalysisEngine.instance.logger.logError2("Could not resolve script tag", exception);
+          AnalysisEngine.instance.logger.logError2("Could not resolve script tag", new CaughtException(exception, stackTrace));
         }
         node.scriptElement = script;
         _scripts.add(script);
       } else {
         ExternalHtmlScriptElementImpl script = new ExternalHtmlScriptElementImpl(node);
         if (scriptSourcePath != null) {
           try {
             scriptSourcePath = Uri.encodeFull(scriptSourcePath);
             // Force an exception to be thrown if the URI is invalid so that we can report the
             // problem.
@@ skipping 527 matching lines @@
   /**
    * Resolve the given node, reporting any errors or warnings to the given listener.
    *
    * @param node the root of the AST structure to be resolved
    * @throws AnalysisException if the node could not be resolved
    */
   void resolve(AstNode node) {
     AstNode rootNode = _findResolutionRoot(node);
     Scope scope = ScopeBuilder.scopeFor(rootNode, _errorListener);
     if (_elementModelChanged(rootNode.parent)) {
-      throw new AnalysisException.con1("Cannot resolve node: element model changed");
+      throw new AnalysisException("Cannot resolve node: element model changed");
     }
     _resolveTypes(node, scope);
     _resolveVariables(node, scope);
     _resolveReferences(node, scope);
   }
 
   /**
    * Return `true` if the given node can be resolved independently of any other nodes.
    *
    * <b>Note:</b> This method needs to be kept in sync with [ScopeBuilder#scopeForAstNode].
    *
    * @param node the node being tested
    * @return `true` if the given node can be resolved independently of any other nodes
    */
   bool _canBeResolved(AstNode node) => node is ClassDeclaration || node is ClassTypeAlias || node is CompilationUnit || node is ConstructorDeclaration || node is FunctionDeclaration || node is FunctionTypeAlias || node is MethodDeclaration;
 
   /**
    * Return `true` if the portion of the element model defined by the given node has changed.
    *
    * @param node the node defining the portion of the element model being tested
    * @return `true` if the element model defined by the given node has changed
    * @throws AnalysisException if the correctness of the element model cannot be determined
    */
   bool _elementModelChanged(AstNode node) {
     Element element = _getElement(node);
     if (element == null) {
-      throw new AnalysisException.con1("Cannot resolve node: a ${node.runtimeType.toString()} does not define an element");
+      throw new AnalysisException("Cannot resolve node: a ${node.runtimeType.toString()} does not define an element");
     }
     DeclarationMatcher matcher = new DeclarationMatcher();
     return !matcher.matches(node, element);
   }
 
   /**
    * Starting at the given node, find the smallest AST node that can be resolved independently of
    * any other nodes. Return the node that was found.
    *
    * @param node the node at which the search is to begin
    * @return the smallest AST node that can be resolved independently of any other nodes
    * @throws AnalysisException if there is no such node
    */
   AstNode _findResolutionRoot(AstNode node) {
     AstNode result = node;
     AstNode parent = result.parent;
     while (parent != null && !_canBeResolved(parent)) {
       result = parent;
       parent = result.parent;
     }
     if (parent == null) {
-      throw new AnalysisException.con1("Cannot resolve node: no resolvable node");
+      throw new AnalysisException("Cannot resolve node: no resolvable node");
     }
     return result;
   }
 
   /**
    * Return the element defined by the given node, or `null` if the node does not define an
    * element.
    *
    * @param node the node defining the element to be returned
    * @return the element defined by the given node
@@ skipping 1153 matching lines @@
 
   /**
    * Return the library element representing this library, creating it if necessary.
    *
    * @return the library element representing this library
    */
   LibraryElementImpl get libraryElement {
     if (_libraryElement == null) {
       try {
         _libraryElement = _analysisContext.computeLibraryElement(librarySource) as LibraryElementImpl;
-      } on AnalysisException catch (exception) {
-        AnalysisEngine.instance.logger.logError2("Could not compute library element for ${librarySource.fullName}", exception);
+      } on AnalysisException catch (exception, stackTrace) {
+        AnalysisEngine.instance.logger.logError2("Could not compute library element for ${librarySource.fullName}", new CaughtException(exception, stackTrace));
       }
     }
     return _libraryElement;
   }
 
   /**
    * Return the library scope used when resolving elements within this library's compilation units.
    *
    * @return the library scope used when resolving elements within this library's compilation units
    */
@@ skipping 623 matching lines @@
       instrumentation.data3("fullName", librarySource.fullName);
       //
       // Create the objects representing the library being resolved and the core library.
       //
       Library targetLibrary = _createLibraryWithUnit(librarySource, modificationStamp, unit);
       _coreLibrary = _libraryMap[_coreLibrarySource];
       if (_coreLibrary == null) {
         // This will be true unless the library being analyzed is the core library.
         _coreLibrary = createLibrary(_coreLibrarySource);
         if (_coreLibrary == null) {
-          throw new AnalysisException.con1("Core library does not exist");
+          throw new AnalysisException("Core library does not exist");
         }
       }
       instrumentation.metric3("createLibrary", "complete");
       //
       // Compute the set of libraries that need to be resolved together.
       //
       _computeEmbeddedLibraryDependencies(targetLibrary, unit);
       _librariesInCycles = _computeLibrariesInCycles(targetLibrary);
       //
       // Build the element models representing the libraries being resolved. This is done in three
       // steps:
       //
       // 1. Build the basic element models without making any connections between elements other than
       //    the basic parent/child relationships. This includes building the elements representing the
       //    libraries.
       // 2. Build the elements for the import and export directives. This requires that we have the
       //    elements built for the referenced libraries, but because of the possibility of circular
       //    references needs to happen after all of the library elements have been created.
       // 3. Build the rest of the type model by connecting superclasses, mixins, and interfaces. This
       //    requires that we be able to compute the names visible in the libraries being resolved,
       //    which in turn requires that we have resolved the import directives.
       //
       _buildElementModels();
       instrumentation.metric3("buildElementModels", "complete");
       LibraryElement coreElement = _coreLibrary.libraryElement;
       if (coreElement == null) {
-        throw new AnalysisException.con1("Could not resolve dart:core");
+        throw new AnalysisException("Could not resolve dart:core");
       }
       _buildDirectiveModels();
       instrumentation.metric3("buildDirectiveModels", "complete");
       _typeProvider = new TypeProviderImpl(coreElement);
       _buildTypeHierarchies();
       instrumentation.metric3("buildTypeHierarchies", "complete");
       //
       // Perform resolution and type analysis.
       //
       // TODO(brianwilkerson) Decide whether we want to resolve all of the libraries or whether we
@@ skipping 36 matching lines @@
       instrumentation.data3("fullName", librarySource.fullName);
       //
       // Create the objects representing the library being resolved and the core library.
       //
       Library targetLibrary = createLibrary(librarySource);
       _coreLibrary = _libraryMap[_coreLibrarySource];
       if (_coreLibrary == null) {
         // This will be true unless the library being analyzed is the core library.
         _coreLibrary = _createLibraryOrNull(_coreLibrarySource);
         if (_coreLibrary == null) {
-          throw new AnalysisException.con1("Core library does not exist");
+          throw new AnalysisException("Core library does not exist");
         }
       }
       instrumentation.metric3("createLibrary", "complete");
       //
       // Compute the set of libraries that need to be resolved together.
       //
       _computeLibraryDependencies(targetLibrary);
       _librariesInCycles = _computeLibrariesInCycles(targetLibrary);
       //
       // Build the element models representing the libraries being resolved. This is done in three
       // steps:
       //
       // 1. Build the basic element models without making any connections between elements other than
       //    the basic parent/child relationships. This includes building the elements representing the
       //    libraries.
       // 2. Build the elements for the import and export directives. This requires that we have the
       //    elements built for the referenced libraries, but because of the possibility of circular
       //    references needs to happen after all of the library elements have been created.
       // 3. Build the rest of the type model by connecting superclasses, mixins, and interfaces. This
       //    requires that we be able to compute the names visible in the libraries being resolved,
       //    which in turn requires that we have resolved the import directives.
       //
       _buildElementModels();
       instrumentation.metric3("buildElementModels", "complete");
       LibraryElement coreElement = _coreLibrary.libraryElement;
       if (coreElement == null) {
-        throw new AnalysisException.con1("Could not resolve dart:core");
+        throw new AnalysisException("Could not resolve dart:core");
       }
       _buildDirectiveModels();
       instrumentation.metric3("buildDirectiveModels", "complete");
       _typeProvider = new TypeProviderImpl(coreElement);
       _buildTypeHierarchies();
       instrumentation.metric3("buildTypeHierarchies", "complete");
       //
       // Perform resolution and type analysis.
       //
       // TODO(brianwilkerson) Decide whether we want to resolve all of the libraries or whether we
@@ skipping 432 matching lines @@
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
     try {
       ConstantValueComputer computer = new ConstantValueComputer(_typeProvider);
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           try {
             CompilationUnit unit = library.getAST(source);
             if (unit != null) {
               computer.add(unit);
             }
-          } on AnalysisException catch (exception) {
-            AnalysisEngine.instance.logger.logError2("Internal Error: Could not access AST for ${source.fullName} during constant evaluation", exception);
+          } on AnalysisException catch (exception, stackTrace) {
+            AnalysisEngine.instance.logger.logError2("Internal Error: Could not access AST for ${source.fullName} during constant evaluation", new CaughtException(exception, stackTrace));
           }
         }
       }
       computer.computeValues();
     } finally {
       timeCounter.stop();
     }
   }
 
   /**
@@ skipping 173 matching lines @@
       //    elements built for the referenced libraries, but because of the possibility of circular
       //    references needs to happen after all of the library elements have been created.
       // 3. Build the rest of the type model by connecting superclasses, mixins, and interfaces. This
       //    requires that we be able to compute the names visible in the libraries being resolved,
       //    which in turn requires that we have resolved the import directives.
       //
       _buildElementModels();
       instrumentation.metric3("buildElementModels", "complete");
       LibraryElement coreElement = _coreLibrary.libraryElement;
       if (coreElement == null) {
-        throw new AnalysisException.con1("Could not resolve dart:core");
+        throw new AnalysisException("Could not resolve dart:core");
       }
       _buildDirectiveModels();
       instrumentation.metric3("buildDirectiveModels", "complete");
       _typeProvider = new TypeProviderImpl(coreElement);
       _buildTypeHierarchies();
       instrumentation.metric3("buildTypeHierarchies", "complete");
       //
       // Perform resolution and type analysis.
       //
       // TODO(brianwilkerson) Decide whether we want to resolve all of the libraries or whether we
@@ skipping 3104 matching lines @@
    * Return the scope in which the given AST structure should be resolved.
    *
    * @param node the root of the AST structure to be resolved
    * @param errorListener the listener to which analysis errors will be reported
    * @return the scope in which the given AST structure should be resolved
    * @throws AnalysisException if the AST structure has not been resolved or is not part of a
    *           [CompilationUnit]
    */
   static Scope scopeFor(AstNode node, AnalysisErrorListener errorListener) {
     if (node == null) {
-      throw new AnalysisException.con1("Cannot create scope: node is null");
+      throw new AnalysisException("Cannot create scope: node is null");
     } else if (node is CompilationUnit) {
       ScopeBuilder builder = new ScopeBuilder(errorListener);
       return builder._scopeForAstNode(node);
     }
     AstNode parent = node.parent;
     if (parent == null) {
-      throw new AnalysisException.con1("Cannot create scope: node is not part of a CompilationUnit");
+      throw new AnalysisException("Cannot create scope: node is not part of a CompilationUnit");
     }
     ScopeBuilder builder = new ScopeBuilder(errorListener);
     return builder._scopeForAstNode(parent);
   }
 
   /**
    * The listener to which analysis errors will be reported.
    */
   final AnalysisErrorListener _errorListener;
 
@@ skipping 15 matching lines @@
    * @return the scope in which the given AST structure should be resolved
    * @throws AnalysisException if the AST structure has not been resolved or is not part of a
    *           [CompilationUnit]
    */
   Scope _scopeForAstNode(AstNode node) {
     if (node is CompilationUnit) {
       return _scopeForCompilationUnit(node);
     }
     AstNode parent = node.parent;
     if (parent == null) {
-      throw new AnalysisException.con1("Cannot create scope: node is not part of a CompilationUnit");
+      throw new AnalysisException("Cannot create scope: node is not part of a CompilationUnit");
     }
     Scope scope = _scopeForAstNode(parent);
     if (node is ClassDeclaration) {
       ClassElement element = node.element;
       if (element == null) {
-        throw new AnalysisException.con1("Cannot build a scope for an unresolved class");
+        throw new AnalysisException("Cannot build a scope for an unresolved class");
       }
       scope = new ClassScope(scope, element);
     } else if (node is ClassTypeAlias) {
       ClassElement element = node.element;
       if (element == null) {
-        throw new AnalysisException.con1("Cannot build a scope for an unresolved class type alias");
+        throw new AnalysisException("Cannot build a scope for an unresolved class type alias");
       }
       scope = new ClassScope(scope, element);
     } else if (node is ConstructorDeclaration) {
       ConstructorElement element = node.element;
       if (element == null) {
-        throw new AnalysisException.con1("Cannot build a scope for an unresolved constructor");
+        throw new AnalysisException("Cannot build a scope for an unresolved constructor");
       }
       FunctionScope functionScope = new FunctionScope(scope, element);
       functionScope.defineParameters();
       scope = functionScope;
     } else if (node is FunctionDeclaration) {
       ExecutableElement element = node.element;
       if (element == null) {
-        throw new AnalysisException.con1("Cannot build a scope for an unresolved function");
+        throw new AnalysisException("Cannot build a scope for an unresolved function");
       }
       FunctionScope functionScope = new FunctionScope(scope, element);
       functionScope.defineParameters();
       scope = functionScope;
     } else if (node is FunctionTypeAlias) {
       scope = new FunctionTypeScope(scope, node.element);
     } else if (node is MethodDeclaration) {
       ExecutableElement element = node.element;
       if (element == null) {
-        throw new AnalysisException.con1("Cannot build a scope for an unresolved method");
+        throw new AnalysisException("Cannot build a scope for an unresolved method");
       }
       FunctionScope functionScope = new FunctionScope(scope, element);
       functionScope.defineParameters();
       scope = functionScope;
     }
     return scope;
   }
 
   Scope _scopeForCompilationUnit(CompilationUnit node) {
     CompilationUnitElement unitElement = node.element;
     if (unitElement == null) {
-      throw new AnalysisException.con1("Cannot create scope: compilation unit is not resolved");
+      throw new AnalysisException("Cannot create scope: compilation unit is not resolved");
     }
     LibraryElement libraryElement = unitElement.library;
     if (libraryElement == null) {
-      throw new AnalysisException.con1("Cannot create scope: compilation unit is not part of a library");
+      throw new AnalysisException("Cannot create scope: compilation unit is not part of a library");
     }
     return new LibraryScope(libraryElement, _errorListener);
   }
 }
 
 /**
  * The abstract class `ScopedVisitor` maintains name and label scopes as an AST structure is
  * being visited.
  */
 abstract class ScopedVisitor extends UnifyingAstVisitor<Object> {
@@ skipping 4306 matching lines @@
         parameterImpl.markPotentiallyMutatedInScope();
         // If we are in some closure, check if it is not the same as where variable is declared.
         if (_enclosingFunction != null && (element.enclosingElement != _enclosingFunction)) {
           parameterImpl.markPotentiallyMutatedInClosure();
         }
       }
     }
     return null;
   }
 }