More improvements to DeclarationResolver.

pkg/analyzer/test/generated/declaration_resolver_test.dart

 // Copyright (c) 2015, 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 engine.declaration_resolver_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
@@ skipping 27 matching lines @@
   return EngineTestCase.findNode(
       root, code, search, (n) => n is SimpleIdentifier);
 }
 
 @reflectiveTest
 class DeclarationResolverMetadataTest extends ResolverTestCase {
   String code;
   CompilationUnit unit;
   CompilationUnit unit2;
 
-  void checkMetadata(String search) {
+  void checkMetadata(String search, {bool expectDifferent: false}) {
     NodeList<Annotation> metadata = _findMetadata(unit, search);
     NodeList<Annotation> metadata2 = _findMetadata(unit2, search);
     expect(metadata, isNotEmpty);
     for (int i = 0; i < metadata.length; i++) {
-      expect(
-          metadata2[i].elementAnnotation, same(metadata[i].elementAnnotation));
+      Matcher expectation = same(metadata[i].elementAnnotation);
+      if (expectDifferent) {
+        expectation = isNot(expectation);
+      }
+      expect(metadata2[i].elementAnnotation, expectation);
     }
   }
 
   void setupCode(String code) {
     this.code = code;
     unit = resolveSource(code + ' const a = null;');
     unit2 = _cloneResolveUnit(unit);
   }
 
   void test_metadata_classDeclaration() {
@@ skipping 11 matching lines @@
     checkMetadata('x');
   }
 
   void test_metadata_constructorDeclaration_unnamed() {
     setupCode('class C { @a C(); }');
     checkMetadata('C()');
   }
 
   void test_metadata_declaredIdentifier() {
     setupCode('f(x, y) { for (@a var x in y) {} }');
-    checkMetadata('var');
+    checkMetadata('var', expectDifferent: true);
   }
 
   void test_metadata_enumDeclaration() {
     setupCode('@a enum E { v }');
     checkMetadata('E');
   }
 
   void test_metadata_exportDirective() {
     addNamedSource('/foo.dart', 'class C {}');
     setupCode('@a export "foo.dart";');
@@ skipping 71 matching lines @@
     setupCode('f() { @a g() {} }');
     // Note: metadata on local function declarations is ignored by the
     // analyzer.  TODO(paulberry): is this a bug?
     FunctionDeclaration node = EngineTestCase.findNode(
         unit, code, 'g', (AstNode n) => n is FunctionDeclaration);
     expect((node as FunctionDeclarationImpl).metadata, isEmpty);
   }
 
   void test_metadata_localVariableDeclaration() {
     setupCode('f() { @a int x; }');
-    checkMetadata('x');
+    checkMetadata('x', expectDifferent: true);
   }
 
   void test_metadata_methodDeclaration_getter() {
     setupCode('class C { @a get m => null; }');
     checkMetadata('m');
   }
 
   void test_metadata_methodDeclaration_method() {
     setupCode('class C { @a m() {} }');
     checkMetadata('m');
@@ skipping 62 matching lines @@
   }
 }
 
 @reflectiveTest
 class DeclarationResolverTest extends ResolverTestCase {
   @override
   void setUp() {
     super.setUp();
   }
 
+  void test_closure_inside_catch_block() {
+    String code = '''
+f() {
+  try {
+  } catch (e) {
+    return () => null;
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(code);
+    // re-resolve
+    _cloneResolveUnit(unit);
+    // no other validations than built into DeclarationResolver
+  }
+
+  void test_closure_inside_labeled_statement() {
+    String code = '''
+f(b) {
+  foo: while (true) {
+    if (b) {
+      break foo;
+    }
+    return () => null;
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(code);
+    // re-resolve
+    _cloneResolveUnit(unit);
+    // no other validations than built into DeclarationResolver
+  }
+
+  void test_closure_inside_switch_case() {
+    String code = '''
+void f(k, m) {
+  switch (k) {
+    case 0:
+      m.forEach((key, value) {});
+    break;
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(code);
+    // re-resolve
+    _cloneResolveUnit(unit);
+    // no other validations than built into DeclarationResolver
+  }
+
+  void test_closure_inside_switch_default() {
+    String code = '''
+void f(k, m) {
+  switch (k) {
+    default:
+      m.forEach((key, value) {});
+    break;
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(code);
+    // re-resolve
+    _cloneResolveUnit(unit);
+    // no other validations than built into DeclarationResolver
+  }
+
   void test_enumConstant_partiallyResolved() {
     String code = r'''
 enum Fruit {apple, pear}
 ''';
     Source source = addNamedSource('/test.dart', code);
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     analysisContext.computeResult(source, LIBRARY_ELEMENT1);
     CompilationUnit unit =
         analysisContext.computeResult(target, RESOLVED_UNIT1);
     _cloneResolveUnit(unit);
@@ skipping 265 matching lines @@
     expect(element.type.toString(), "<T>(T, T) → T");
     expect(t.element, same(tElement));
 
     // re-resolve
     CompilationUnit unit2 = _cloneResolveUnit(unit);
     node = _findSimpleIdentifier(unit2, code, 'max').parent;
     t = node.typeParameters.typeParameters[0];
     expect(t.element, same(tElement));
   }
 }