Don't log stack trace for a bad package URL in a source file.

pkg/analyzer/test/generated/all_the_rest_test.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.
 
 library analyzer.test.generated.all_the_rest_test;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 557 matching lines @@
     _setupVariableDeclaration("v", false, true);
     expect(_findConstants(), isEmpty);
   }
 
   void test_visitVariableDeclaration_static_const_inClass() {
     VariableDeclaration field =
         _setupFieldDeclaration('C', 'f', Keyword.CONST, isStatic: true);
     expect(_findConstants(), contains(field.element));
   }
 
-  void
-      test_visitVariableDeclaration_static_const_inClassWithConstConstructor() {
+  void test_visitVariableDeclaration_static_const_inClassWithConstConstructor() {

[skybrian, 2016/01/09 08:19:54]

Not sure what dartfmt is doing here; it seems to have reversed a previous patch:
https://codereview.chromium.org/1524893002/patch/1/10027

[Brian Wilkerson, 2016/01/09 16:02:39]

I'm not sure either, but we always format, regardless of what the formatter
does, so you don't need to worry about it.

     VariableDeclaration field = _setupFieldDeclaration('C', 'f', Keyword.CONST,
         isStatic: true, hasConstConstructor: true);
     expect(_findConstants(), contains(field.element));
   }
 
-  void
-      test_visitVariableDeclaration_static_final_inClassWithConstConstructor() {
+  void test_visitVariableDeclaration_static_final_inClassWithConstConstructor() {
     VariableDeclaration field = _setupFieldDeclaration('C', 'f', Keyword.FINAL,
         isStatic: true, hasConstConstructor: true);
     expect(_findConstants(), isNot(contains(field.element)));
   }
 
-  void
-      test_visitVariableDeclaration_uninitialized_final_inClassWithConstConstructor() {
+  void test_visitVariableDeclaration_uninitialized_final_inClassWithConstConstructor() {
     VariableDeclaration field = _setupFieldDeclaration('C', 'f', Keyword.FINAL,
         isInitialized: false, hasConstConstructor: true);
     expect(_findConstants(), isNot(contains(field.element)));
   }
 
   void test_visitVariableDeclaration_uninitialized_static_const_inClass() {
     _setupFieldDeclaration('C', 'f', Keyword.CONST,
         isStatic: true, isInitialized: false);
     expect(_findConstants(), isEmpty);
   }
@@ skipping 13 matching lines @@
   Set<ConstantEvaluationTarget> _findConstants() {
     ConstantFinder finder = new ConstantFinder(_context, _source, _source);
     _node.accept(finder);
     Set<ConstantEvaluationTarget> constants = finder.constantsToCompute;
     expect(constants, isNotNull);
     return constants;
   }
 
   ConstructorElement _setupConstructorDeclaration(String name, bool isConst) {
     Keyword constKeyword = isConst ? Keyword.CONST : null;
-    ConstructorDeclaration constructorDeclaration =
-        AstFactory.constructorDeclaration2(
+    ConstructorDeclaration constructorDeclaration = AstFactory
+        .constructorDeclaration2(
             constKeyword,
             null,
             null,
             name,
             AstFactory.formalParameterList(),
             null,
             AstFactory.blockFunctionBody2());
     ClassElement classElement = ElementFactory.classElement2(name);
     ConstructorElement element =
         ElementFactory.constructorElement(classElement, name, isConst);
@@ skipping 20 matching lines @@
     FieldDeclaration fieldDeclaration = AstFactory.fieldDeclaration2(
         isStatic, keyword, <VariableDeclaration>[variableDeclaration]);
     ClassDeclaration classDeclaration =
         AstFactory.classDeclaration(null, className, null, null, null, null);
     classDeclaration.members.add(fieldDeclaration);
     _node = classDeclaration;
     ClassElementImpl classElement = ElementFactory.classElement2(className);
     classElement.fields = <FieldElement>[fieldElement];
     classDeclaration.name.staticElement = classElement;
     if (hasConstConstructor) {
-      ConstructorDeclaration constructorDeclaration =
-          AstFactory.constructorDeclaration2(
+      ConstructorDeclaration constructorDeclaration = AstFactory
+          .constructorDeclaration2(
               Keyword.CONST,
               null,
               AstFactory.identifier3(className),
               null,
               AstFactory.formalParameterList(),
               null,
               AstFactory.blockFunctionBody2());
       classDeclaration.members.add(constructorDeclaration);
       ConstructorElement constructorElement =
           ElementFactory.constructorElement(classElement, '', true);
@@ skipping 192 matching lines @@
   @i(1)
   f() {}
 }
 ''');
     _evaluateAnnotation(compilationUnit, "C", "f");
   }
 
   void test_computeValues_cycle() {
     TestLogger logger = new TestLogger();
     AnalysisEngine.instance.logger = logger;
-    Source librarySource = addSource(r'''
-const int a = c;
-const int b = a;
-const int c = b;''');
-    LibraryElement libraryElement = resolve2(librarySource);
-    CompilationUnit unit =
-        analysisContext.resolveCompilationUnit(librarySource, libraryElement);
-    analysisContext.computeErrors(librarySource);
-    expect(unit, isNotNull);
-    ConstantValueComputer computer = _makeConstantValueComputer();
-    computer.add(unit, librarySource, librarySource);
-    computer.computeValues();
-    NodeList<CompilationUnitMember> members = unit.declarations;
-    expect(members, hasLength(3));
-    _validate(false, (members[0] as TopLevelVariableDeclaration).variables);
-    _validate(false, (members[1] as TopLevelVariableDeclaration).variables);
-    _validate(false, (members[2] as TopLevelVariableDeclaration).variables);
+    try {
+      Source librarySource = addSource(r'''
+  const int a = c;
+  const int b = a;
+  const int c = b;''');
+      LibraryElement libraryElement = resolve2(librarySource);
+      CompilationUnit unit =
+          analysisContext.resolveCompilationUnit(librarySource, libraryElement);
+      analysisContext.computeErrors(librarySource);
+      expect(unit, isNotNull);
+      ConstantValueComputer computer = _makeConstantValueComputer();
+      computer.add(unit, librarySource, librarySource);
+      computer.computeValues();
+      NodeList<CompilationUnitMember> members = unit.declarations;
+      expect(members, hasLength(3));
+      _validate(false, (members[0] as TopLevelVariableDeclaration).variables);
+      _validate(false, (members[1] as TopLevelVariableDeclaration).variables);
+      _validate(false, (members[2] as TopLevelVariableDeclaration).variables);
+    } finally {
+      AnalysisEngine.instance.logger = Logger.NULL;
+    }
   }
 
   void test_computeValues_dependentVariables() {
     Source librarySource = addSource(r'''
 const int b = a;
 const int a = 0;''');
     LibraryElement libraryElement = resolve2(librarySource);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(unit, isNotNull);
@@ skipping 415 matching lines @@
   const A(int i, int j) : k = 2 * i + j;
   final int k;
 }''');
     EvaluationResultImpl result =
         _evaluateTopLevelVariable(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     expect(fields, hasLength(1));
     _assertIntField(fields, "k", 13);
   }
 
-  void
-      test_instanceCreationExpression_computedField_namedOptionalWithDefault() {
+  void test_instanceCreationExpression_computedField_namedOptionalWithDefault() {
     _checkInstanceCreationOptionalParams(false, true, true);
   }
 
-  void
-      test_instanceCreationExpression_computedField_namedOptionalWithoutDefault() {
+  void test_instanceCreationExpression_computedField_namedOptionalWithoutDefault() {
     _checkInstanceCreationOptionalParams(false, true, false);
   }
 
-  void
-      test_instanceCreationExpression_computedField_unnamedOptionalWithDefault() {
+  void test_instanceCreationExpression_computedField_unnamedOptionalWithDefault() {
     _checkInstanceCreationOptionalParams(false, false, true);
   }
 
-  void
-      test_instanceCreationExpression_computedField_unnamedOptionalWithoutDefault() {
+  void test_instanceCreationExpression_computedField_unnamedOptionalWithoutDefault() {
     _checkInstanceCreationOptionalParams(false, false, false);
   }
 
   void test_instanceCreationExpression_computedField_usesConstConstructor() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A(3);
 class A {
   const A(int i) : b = const B(4);
   final int b;
 }
@@ skipping 72 matching lines @@
   int x;
   const A(this.x)
 }''');
     EvaluationResultImpl result =
         _evaluateTopLevelVariable(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     expect(fields, hasLength(1));
     _assertIntField(fields, "x", 42);
   }
 
-  void
-      test_instanceCreationExpression_fieldFormalParameter_namedOptionalWithDefault() {
+  void test_instanceCreationExpression_fieldFormalParameter_namedOptionalWithDefault() {
     _checkInstanceCreationOptionalParams(true, true, true);
   }
 
-  void
-      test_instanceCreationExpression_fieldFormalParameter_namedOptionalWithoutDefault() {
+  void test_instanceCreationExpression_fieldFormalParameter_namedOptionalWithoutDefault() {
     _checkInstanceCreationOptionalParams(true, true, false);
   }
 
-  void
-      test_instanceCreationExpression_fieldFormalParameter_unnamedOptionalWithDefault() {
+  void test_instanceCreationExpression_fieldFormalParameter_unnamedOptionalWithDefault() {
     _checkInstanceCreationOptionalParams(true, false, true);
   }
 
-  void
-      test_instanceCreationExpression_fieldFormalParameter_unnamedOptionalWithoutDefault() {
+  void test_instanceCreationExpression_fieldFormalParameter_unnamedOptionalWithoutDefault() {
     _checkInstanceCreationOptionalParams(true, false, false);
   }
 
   void test_instanceCreationExpression_implicitSuper() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const B(4);
 class A {
   const A() : x = 3;
   final int x;
 }
@@ skipping 3386 matching lines @@
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type.typeParameters, hasLength(1));
     expect(type.typeParameters[0].name, equals('T'));
   }
 
   void test_visitConstructorDeclaration_external() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "A";
-    ConstructorDeclaration constructorDeclaration =
-        AstFactory.constructorDeclaration2(
+    ConstructorDeclaration constructorDeclaration = AstFactory
+        .constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3(className),
             null,
             AstFactory.formalParameterList(),
             null,
             AstFactory.blockFunctionBody2());
     constructorDeclaration.externalKeyword =
         TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
     constructorDeclaration.accept(builder);
     List<ConstructorElement> constructors = holder.constructors;
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isExternal, isTrue);
     expect(constructor.isFactory, isFalse);
     expect(constructor.name, "");
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
     expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, hasLength(0));
   }
 
   void test_visitConstructorDeclaration_factory() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "A";
-    ConstructorDeclaration constructorDeclaration =
-        AstFactory.constructorDeclaration2(
+    ConstructorDeclaration constructorDeclaration = AstFactory
+        .constructorDeclaration2(
             null,
             Keyword.FACTORY,
             AstFactory.identifier3(className),
             null,
             AstFactory.formalParameterList(),
             null,
             AstFactory.blockFunctionBody2());
     constructorDeclaration.accept(builder);
     List<ConstructorElement> constructors = holder.constructors;
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isExternal, isFalse);
     expect(constructor.isFactory, isTrue);
     expect(constructor.name, "");
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
     expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, hasLength(0));
   }
 
   void test_visitConstructorDeclaration_minimal() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "A";
-    ConstructorDeclaration constructorDeclaration =
-        AstFactory.constructorDeclaration2(
+    ConstructorDeclaration constructorDeclaration = AstFactory
+        .constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3(className),
             null,
             AstFactory.formalParameterList(),
             null,
             AstFactory.blockFunctionBody2());
     constructorDeclaration.documentationComment = AstFactory
         .documentationComment(
             [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
@@ skipping 11 matching lines @@
     expect(constructor.labels, hasLength(0));
     expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, hasLength(0));
   }
 
   void test_visitConstructorDeclaration_named() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "A";
     String constructorName = "c";
-    ConstructorDeclaration constructorDeclaration =
-        AstFactory.constructorDeclaration2(
+    ConstructorDeclaration constructorDeclaration = AstFactory
+        .constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3(className),
             constructorName,
             AstFactory.formalParameterList(),
             null,
             AstFactory.blockFunctionBody2());
     constructorDeclaration.accept(builder);
     List<ConstructorElement> constructors = holder.constructors;
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isExternal, isFalse);
     expect(constructor.isFactory, isFalse);
     expect(constructor.name, constructorName);
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
     expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, hasLength(0));
     expect(constructorDeclaration.name.staticElement, same(constructor));
     expect(constructorDeclaration.element, same(constructor));
   }
 
   void test_visitConstructorDeclaration_unnamed() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "A";
-    ConstructorDeclaration constructorDeclaration =
-        AstFactory.constructorDeclaration2(
+    ConstructorDeclaration constructorDeclaration = AstFactory
+        .constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3(className),
             null,
             AstFactory.formalParameterList(),
             null,
             AstFactory.blockFunctionBody2());
     constructorDeclaration.accept(builder);
     List<ConstructorElement> constructors = holder.constructors;
     expect(constructors, hasLength(1));
@@ skipping 59 matching lines @@
     expect(variable.isPublic, isTrue);
     expect(variable.isSynthetic, isFalse);
     expect(variable.name, variableName);
   }
 
   void test_visitDefaultFormalParameter_noType() {
     // p = 0
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String parameterName = 'p';
-    DefaultFormalParameter formalParameter =
-        AstFactory.positionalFormalParameter(
+    DefaultFormalParameter formalParameter = AstFactory
+        .positionalFormalParameter(
             AstFactory.simpleFormalParameter3(parameterName),
             AstFactory.integer(0));
     formalParameter.accept(builder);
 
     List<ParameterElement> parameters = holder.parameters;
     expect(parameters, hasLength(1));
     ParameterElement parameter = parameters[0];
     expect(parameter.hasImplicitType, isTrue);
     expect(parameter.isConst, isFalse);
     expect(parameter.isDeprecated, isFalse);
@@ skipping 1384 matching lines @@
 
   void test_locate_FunctionDeclaration() {
     AstNode id = _findNodeIn("f", "int f() => 3;");
     FunctionDeclaration declaration =
         id.getAncestor((node) => node is FunctionDeclaration);
     Element element = ElementLocator.locate(declaration);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionElement, FunctionElement, element);
   }
 
-  void
-      test_locate_Identifier_annotationClass_namedConstructor_forSimpleFormalParameter() {
+  void test_locate_Identifier_annotationClass_namedConstructor_forSimpleFormalParameter() {
     AstNode id = _findNodeIndexedIn(
         "Class",
         2,
         r'''
 class Class {
   const Class.name();
 }
 void main(@Class.name() parameter) {
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassElement, ClassElement, element);
   }
 
-  void
-      test_locate_Identifier_annotationClass_unnamedConstructor_forSimpleFormalParameter() {
+  void test_locate_Identifier_annotationClass_unnamedConstructor_forSimpleFormalParameter() {
     AstNode id = _findNodeIndexedIn(
         "Class",
         2,
         r'''
 class Class {
   const Class();
 }
 void main(@Class() parameter) {
 }''');
     Element element = ElementLocator.locate(id);
@@ skipping 86 matching lines @@
     Element element = ElementLocator.locate(node);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement, ConstructorElement, element);
   }
 
   void test_locate_InstanceCreationExpression_type_prefixedIdentifier() {
     // prepare: new pref.A()
     SimpleIdentifier identifier = AstFactory.identifier3("A");
     PrefixedIdentifier prefixedIdentifier =
         AstFactory.identifier4("pref", identifier);
-    InstanceCreationExpression creation =
-        AstFactory.instanceCreationExpression2(
+    InstanceCreationExpression creation = AstFactory
+        .instanceCreationExpression2(
             Keyword.NEW, AstFactory.typeName3(prefixedIdentifier));
     // set ClassElement
     ClassElement classElement = ElementFactory.classElement2("A");
     identifier.staticElement = classElement;
     // set ConstructorElement
     ConstructorElement constructorElement =
         ElementFactory.constructorElement2(classElement, null);
     creation.constructorName.staticElement = constructorElement;
     // verify that "A" is resolved to ConstructorElement
     Element element = ElementLocator.locate(identifier);
     expect(element, same(classElement));
   }
 
   void test_locate_InstanceCreationExpression_type_simpleIdentifier() {
     // prepare: new A()
     SimpleIdentifier identifier = AstFactory.identifier3("A");
-    InstanceCreationExpression creation =
-        AstFactory.instanceCreationExpression2(
+    InstanceCreationExpression creation = AstFactory
+        .instanceCreationExpression2(
             Keyword.NEW, AstFactory.typeName3(identifier));
     // set ClassElement
     ClassElement classElement = ElementFactory.classElement2("A");
     identifier.staticElement = classElement;
     // set ConstructorElement
     ConstructorElement constructorElement =
         ElementFactory.constructorElement2(classElement, null);
     creation.constructorName.staticElement = constructorElement;
     // verify that "A" is resolved to ConstructorElement
     Element element = ElementLocator.locate(identifier);
@@ skipping 1484 matching lines @@
   }
 
   ReferenceFinder _createReferenceFinder(ConstantEvaluationTarget source) =>
       new ReferenceFinder((ConstantEvaluationTarget dependency) {
         _referenceGraph.addEdge(source, dependency);
       });
   SuperConstructorInvocation _makeTailSuperConstructorInvocation(
       String name, bool isConst) {
     List<ConstructorInitializer> initializers =
         new List<ConstructorInitializer>();
-    ConstructorDeclaration constructorDeclaration =
-        AstFactory.constructorDeclaration(AstFactory.identifier3(name), null,
+    ConstructorDeclaration constructorDeclaration = AstFactory
+        .constructorDeclaration(AstFactory.identifier3(name), null,
             AstFactory.formalParameterList(), initializers);
     if (isConst) {
       constructorDeclaration.constKeyword = new KeywordToken(Keyword.CONST, 0);
     }
     ClassElementImpl classElement = ElementFactory.classElement2(name);
     SuperConstructorInvocation superConstructorInvocation =
         AstFactory.superConstructorInvocation();
     ConstructorElementImpl constructorElement =
         ElementFactory.constructorElement(classElement, name, isConst);
     _tail = constructorElement;
@@ skipping 113 matching lines @@
     expect(UriKind.fromEncoding(0x70), same(UriKind.PACKAGE_URI));
     expect(UriKind.fromEncoding(0x58), same(null));
   }
 
   void test_getEncoding() {
     expect(UriKind.DART_URI.encoding, 0x64);
     expect(UriKind.FILE_URI.encoding, 0x66);
     expect(UriKind.PACKAGE_URI.encoding, 0x70);
   }
 }