Issue 22962. Adding/removing method/accessor body is a declartion mismatch.

pkg/analyzer/test/generated/incremental_resolver_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 engine.incremental_resolver_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 892 matching lines @@
   void test_false_FunctionTypedFormalParameter_wasSimple() {
     _assertDoesNotMatch(r'''
 main(int callback) {
 }
 ''', r'''
 main(int callback(int a, String b)) {
 }
 ''');
   }
 
+  void test_false_getter_body_add() {
+    _assertDoesNotMatchOK(r'''
+class A {
+  int get foo;
+}
+''', r'''
+class A {
+  int get foo => 0;
+}
+''');
+  }
+
+  void test_false_getter_body_remove() {
+    _assertDoesNotMatchOK(r'''
+class A {
+  int get foo => 0;
+}
+''', r'''
+class A {
+  int get foo;
+}
+''');
+  }
+
   void test_false_implementsClause_add() {
     _assertDoesNotMatch(r'''
 class A {}
 class B {}
 ''', r'''
 class A {}
 class B implements A {}
 ''');
   }
 
@@ skipping 158 matching lines @@
 class A {
   m() async {}
 }
 ''', r'''
 class A {
   m() {}
 }
 ''');
   }
 
+  void test_false_method_body_add() {
+    _assertDoesNotMatchOK(r'''
+class A {
+  void foo();
+}
+''', r'''
+class A {
+  void foo() {}
+}
+''');
+  }
+
+  void test_false_method_body_remove() {
+    _assertDoesNotMatchOK(r'''
+class A {
+  void foo() {}
+}
+''', r'''
+class A {
+  void foo();
+}
+''');
+  }
+
   void test_false_method_generator_add() {
     _assertDoesNotMatchOK(r'''
 class A {
   m() async {}
 }
 ''', r'''
 class A {
   m() async* {}
 }
 ''');
@@ skipping 514 matching lines @@
 class M<T> {}
 class A<T> {}
 class B<T> = A<T> with M<T>;
 ''', r'''
 class M<T> {}
 class A<T> {}
 class B<T> = A<T> with M<T>;
 ''');
   }
 
+  void test_true_constructor_body_add() {
+    _assertMatches(r'''
+class A {
+  A(int p);
+}
+''', r'''
+class A {
+  A(int p) {}
+}
+''');
+  }
+
+  void test_true_constructor_body_remove() {
+    _assertMatches(r'''
+class A {
+  A(int p) {}
+}
+''', r'''
+class A {
+  A(int p);
+}
+''');
+  }
+
   void test_true_constructor_named_same() {
     _assertMatches(r'''
 class A {
   A.name(int p);
 }
 ''', r'''
 class A {
   A.name(int p);
 }
 ''');
@@ skipping 2196 matching lines @@
   }
 
   ClassDeclaration _createResolvedClassDeclaration() {
     CompilationUnit unit = _createResolvedCompilationUnit();
     String className = "C";
     ClassDeclaration classNode = AstFactory.classDeclaration(
         null, className, AstFactory.typeParameterList(), null, null, null);
     unit.declarations.add(classNode);
     ClassElement classElement = ElementFactory.classElement2(className);
     classNode.name.staticElement = classElement;
-    (unit.element as CompilationUnitElementImpl).types = <ClassElement>[
-      classElement
-    ];
+    (unit.element as CompilationUnitElementImpl).types =
+        <ClassElement>[classElement];
     return classNode;
   }
 
   ClassTypeAlias _createResolvedClassTypeAlias() {
     CompilationUnit unit = _createResolvedCompilationUnit();
     String className = "C";
     ClassTypeAlias classNode = AstFactory.classTypeAlias(
         className, AstFactory.typeParameterList(), null, null, null, null);
     unit.declarations.add(classNode);
     ClassElement classElement = ElementFactory.classElement2(className);
     classNode.name.staticElement = classElement;
-    (unit.element as CompilationUnitElementImpl).types = <ClassElement>[
-      classElement
-    ];
+    (unit.element as CompilationUnitElementImpl).types =
+        <ClassElement>[classElement];
     return classNode;
   }
 
   CompilationUnit _createResolvedCompilationUnit() {
     CompilationUnit unit = AstFactory.compilationUnit();
     LibraryElementImpl library =
         ElementFactory.library(AnalysisContextFactory.contextWithCore(), "lib");
     unit.element = library.definingCompilationUnit;
     return unit;
   }
 
   ConstructorDeclaration _createResolvedConstructorDeclaration() {
     ClassDeclaration classNode = _createResolvedClassDeclaration();
     String constructorName = "f";
     ConstructorDeclaration constructorNode = AstFactory.constructorDeclaration(
         AstFactory.identifier3(constructorName), null,
         AstFactory.formalParameterList(), null);
     classNode.members.add(constructorNode);
     ConstructorElement constructorElement =
         ElementFactory.constructorElement2(classNode.element, null);
     constructorNode.element = constructorElement;
-    (classNode.element as ClassElementImpl).constructors = <ConstructorElement>[
-      constructorElement
-    ];
+    (classNode.element as ClassElementImpl).constructors =
+        <ConstructorElement>[constructorElement];
     return constructorNode;
   }
 
   FunctionDeclaration _createResolvedFunctionDeclaration() {
     CompilationUnit unit = _createResolvedCompilationUnit();
     String functionName = "f";
     FunctionDeclaration functionNode = AstFactory.functionDeclaration(
         null, null, functionName, AstFactory.functionExpression());
     unit.declarations.add(functionNode);
     FunctionElement functionElement =
         ElementFactory.functionElement(functionName);
     functionNode.name.staticElement = functionElement;
-    (unit.element as CompilationUnitElementImpl).functions = <FunctionElement>[
-      functionElement
-    ];
+    (unit.element as CompilationUnitElementImpl).functions =
+        <FunctionElement>[functionElement];
     return functionNode;
   }
 
   FunctionTypeAlias _createResolvedFunctionTypeAlias() {
     CompilationUnit unit = _createResolvedCompilationUnit();
     FunctionTypeAlias aliasNode = AstFactory.typeAlias(
         AstFactory.typeName4("A"), "F", AstFactory.typeParameterList(),
         AstFactory.formalParameterList());
     unit.declarations.add(aliasNode);
     SimpleIdentifier aliasName = aliasNode.name;
     FunctionTypeAliasElement aliasElement =
         new FunctionTypeAliasElementImpl.forNode(aliasName);
     aliasName.staticElement = aliasElement;
     (unit.element as CompilationUnitElementImpl).typeAliases =
         <FunctionTypeAliasElement>[aliasElement];
     return aliasNode;
   }
 
   MethodDeclaration _createResolvedMethodDeclaration() {
     ClassDeclaration classNode = _createResolvedClassDeclaration();
     String methodName = "f";
     MethodDeclaration methodNode = AstFactory.methodDeclaration(null, null,
         null, null, AstFactory.identifier3(methodName),
         AstFactory.formalParameterList());
     classNode.members.add(methodNode);
     MethodElement methodElement =
         ElementFactory.methodElement(methodName, null);
     methodNode.name.staticElement = methodElement;
-    (classNode.element as ClassElementImpl).methods = <MethodElement>[
-      methodElement
-    ];
+    (classNode.element as ClassElementImpl).methods =
+        <MethodElement>[methodElement];
     return methodNode;
   }
 
   Scope _scopeFor(AstNode node) {
     return ResolutionContextBuilder.contextFor(node, listener).scope;
   }
 }
 
 class _Edit {
   final int offset;
   final int length;
   final String replacement;
   _Edit(this.offset, this.length, this.replacement);
 }