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

pkg/analyzer/lib/src/generated/element.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.element;
 
 import 'dart:collection';
@@ skipping 686 matching lines @@
    */
   void set mixinErrorsReported(bool value) {
     setModifier(Modifier.MIXIN_ERRORS_REPORTED, value);
   }
 
   @override
   AstNode get node {
     if (isEnum) {
       return getNodeMatching((node) => node is EnumDeclaration);
     } else {
-      return getNodeMatching((node) => node is ClassDeclaration || node is ClassTypeAlias);
+      return getNodeMatching(
+          (node) => node is ClassDeclaration || node is ClassTypeAlias);
     }
   }
 
   /**
    * Set whether this class is defined by a typedef construct.
    */
   void set typedef(bool isTypedef) {
     setModifier(Modifier.TYPEDEF, isTypedef);
   }
 
@@ skipping 2513 matching lines @@
  * constructors, getters, and setters.
  */
 abstract class ExecutableElement implements Element {
   /**
    * Return a list containing all of the functions defined within this
    * executable element.
    */
   List<FunctionElement> get functions;
 
   /**
+   * Return `true` if this executable element is abstract.
+   * Executable elements are abstract if they are not external and have no body.
+   */
+  bool get isAbstract;
+
+  /**
    * Return `true` if this executable element has body marked as being
    * asynchronous.
    */
   bool get isAsynchronous;
 
   /**
    * Return `true` if this executable element has a body marked as being a
    * generator.
    */
   bool get isGenerator;
@@ skipping 124 matching lines @@
   }
 
   /**
    * Set whether this method's body is a generator.
    */
   void set generator(bool isGenerator) {
     setModifier(Modifier.GENERATOR, isGenerator);
   }
 
   @override
+  bool get isAbstract => hasModifier(Modifier.ABSTRACT);
+
+  @override
   bool get isAsynchronous => hasModifier(Modifier.ASYNCHRONOUS);
 
   @override
   bool get isGenerator => hasModifier(Modifier.GENERATOR);
 
   @override
   bool get isOperator => false;
 
   @override
   bool get isSynchronous => !hasModifier(Modifier.ASYNCHRONOUS);
@@ skipping 135 matching lines @@
   List<FunctionElement> get functions {
     //
     // Elements within this element should have type parameters substituted,
     // just like this element.
     //
     throw new UnsupportedOperationException();
 //    return getBaseElement().getFunctions();
   }
 
   @override
+  bool get isAbstract => baseElement.isAbstract;
+
+  @override
   bool get isAsynchronous => baseElement.isAsynchronous;
 
   @override
   bool get isGenerator => baseElement.isGenerator;
 
   @override
   bool get isOperator => baseElement.isOperator;
 
   @override
   bool get isStatic => baseElement.isStatic;
@@ skipping 4011 matching lines @@
   void visitChildren(ElementVisitor visitor) {
     // There are no children to visit
   }
 }
 
 /**
  * An element that represents a method defined within a type.
  */
 abstract class MethodElement implements ClassMemberElement, ExecutableElement {
   /**
-   * Return `true` if this method is abstract. Methods are abstract if they are
-   * not external and have no body.
-   */
-  bool get isAbstract;
-
-  /**
    * Return the resolved [MethodDeclaration] node that declares this
    * [MethodElement].
    *
    * This method is expensive, because resolved AST might be evicted from cache,
    * so parsing and resolving will be performed.
    */
   @override
   MethodDeclaration get node;
 }
 
@@ skipping 30 matching lines @@
     if ("unary-" == displayName) {
       return "-";
     }
     return displayName;
   }
 
   @override
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
   @override
-  bool get isAbstract => hasModifier(Modifier.ABSTRACT);
-
-  @override
   bool get isOperator {
     String name = displayName;
     if (name.isEmpty) {
       return false;
     }
     int first = name.codeUnitAt(0);
     return !((0x61 <= first && first <= 0x7A) ||
         (0x41 <= first && first <= 0x5A) ||
         first == 0x5F ||
         first == 0x24);
@@ skipping 51 matching lines @@
   MethodMember(MethodElement baseElement, InterfaceType definingType)
       : super(baseElement, definingType);
 
   @override
   MethodElement get baseElement => super.baseElement as MethodElement;
 
   @override
   ClassElement get enclosingElement => baseElement.enclosingElement;
 
   @override
-  bool get isAbstract => baseElement.isAbstract;
-
-  @override
   MethodDeclaration get node => baseElement.node;
 
   @override
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
 
   @override
   String toString() {
     MethodElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
@@ skipping 909 matching lines @@
   PropertyAccessorElement get correspondingGetter;
 
   /**
    * Return the accessor representing the setter that corresponds to (has the
    * same name as) this getter, or `null` if this accessor is not a getter or if
    * there is no corresponding setter.
    */
   PropertyAccessorElement get correspondingSetter;
 
   /**
-   * Return `true` if this accessor is abstract. Accessors are abstract if they
-   * are not external and have no body.
-   */
-  bool get isAbstract;
-
-  /**
    * Return `true` if this accessor represents a getter.
    */
   bool get isGetter;
 
   /**
    * Return `true` if this accessor represents a setter.
    */
   bool get isSetter;
 
   /**
@@ skipping 71 matching lines @@
   int get hashCode => JenkinsSmiHash.hash2(super.hashCode, isGetter ? 1 : 2);
 
   @override
   String get identifier {
     String name = displayName;
     String suffix = isGetter ? "?" : "=";
     return "$name$suffix";
   }
 
   @override
-  bool get isAbstract => hasModifier(Modifier.ABSTRACT);
-
-  @override
   bool get isGetter => hasModifier(Modifier.GETTER);
 
   @override
   bool get isSetter => hasModifier(Modifier.SETTER);
 
   @override
   bool get isStatic => hasModifier(Modifier.STATIC);
 
   @override
   ElementKind get kind {
@@ skipping 80 matching lines @@
   PropertyAccessorElement get correspondingSetter =>
       from(baseElement.correspondingSetter, definingType);
 
   @override
   InterfaceType get definingType => super.definingType as InterfaceType;
 
   @override
   Element get enclosingElement => baseElement.enclosingElement;
 
   @override
-  bool get isAbstract => baseElement.isAbstract;
-
-  @override
   bool get isGetter => baseElement.isGetter;
 
   @override
   bool get isSetter => baseElement.isSetter;
 
   @override
   PropertyInducingElement get variable {
     PropertyInducingElement variable = baseElement.variable;
     if (variable is FieldElement) {
       return FieldMember.from(variable, definingType);
@@ skipping 1617 matching lines @@
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 
   @override
   VoidTypeImpl substitute2(
       List<DartType> argumentTypes, List<DartType> parameterTypes) => this;
 }