anchor.diff:  /**
    * Instances of a class`MethodElement` is a our abstract representation of methods
    **/
  -class MethodElement extends ClassMember with Block implements Element {
  +class MethodElement extends NamedElement with Block, ClassMember {
     MethodDeclaration ast;
  -  
  -  String get name => isSetter ? setterName : getterName;
  -  String get getterName => ast.name.toString();
  -  String get setterName => FunctionElement.SetterName(getterName);
  +  ClassElement classDecl;
  +  
  +  Name _name;
  +  Name get setterName => Name.SetterName(_name);
  +  Name get getterName => _name;
  +  Name get name => isSetter ? setterName : getterName;
     bool get isAbstract => ast.isAbstract;
     bool get isGetter => ast.isGetter;
     bool get isOperator => ast.isOperator;
  
positive.code:   dynamic accept(ElementVisitor visitor) => visitor.visitElementAnalysis(this);
  }
  
  
  abstract class Element {
    Source get library_source;
    
    String get name;
    bool get fromSystemLibrary => library_source.isInSystemLibrary;
    bool get isPrivate => Identifier.isPrivateName(name);
  }
  /** 
   * Instances of the class `Block` represents a static scope of the program. it could be a Library, a Class, a Method etc.
   * **/ 
  class Block {
  
    Block enclosingBlock = null;
    List<Block> nestedBlocks = <Block>[];
    
    Map<Identifier, Element> resolvedIdentifiers = <Identifier, Element>{};
    Map<SimpleIdentifier, Element> references = <SimpleIdentifier, Element>{};
  
    Block parent_block = null;
    Source get library_source => enclosingBlock.library_source;
    String get name;
    bool get fromSystemLibrary => library_source.isInSystemLibrary;
    bool get isPrivate => Identifier.isPrivateName(name);
  
    Map<String, Element> declaredElements = <String, Element>{};
    Map<String, VariableElement> declaredVariables = <String, VariableElement>{};
    Map<String, FunctionElement> declaredFunctions = <String, FunctionElement>{};
    
    Source get librarySource => enclosingBlock.librarySource;
  
    VariableElement addVariable(SimpleIdentifier ident, VariableElement variable) => declaredVariables[ident] = variable; 
    VariableElement lookupVariableElement(SimpleIdentifier ident) => declaredVariables[ident];
  
    FunctionElement addFunction(Identifier ident, FunctionElement func) => declaredFunctions[ident] = func; 
    FunctionElement lookupFunctionElement(Identifier ident) => declaredFunctions[ident];
    
  }
  
  
  /**
   * Instances of the class `SourceElement` represents a source file and contains all the the information reguarding its content
   **/
  class SourceElement extends Block implements Element {
    
    CompilationUnit ast;
    //If library is `null` it means that the library is implicit named. This means the library name is: ''.
    String libraryName = null;
    SourceElement partOf = null;
    Source source;
    Source get library_source => (partOf == null ? source : partOf.source);
    
    Map<Source, SourceElement> parts = <Source, SourceElement>{};
    
    Map<Source, ImportDirective> imports = <Source, ImportDirective>{};
    Map<Source, ExportDirective> exports = <Source, ExportDirective>{};
    List<ClassElement> classes = <ClassElement>[];
    
    bool implicitImportedDartCore = false;
    
    LibraryElement library = null;
    
    String get name => libraryName;
  
    Map<SimpleIdentifier, VariableElement> get top_variables => declaredVariables;
    
    SourceElement(Source this.source, CompilationUnit this.ast);
    
    ImportDirective addImport(Source source, ImportDirective directive) => imports[source] = directive;
    ExportDirective addExport(Source source, ExportDirective directive) => exports[source] = directive;
    void addPart(Source source, SourceElement element){ parts[source] = element; }
    void addClass(ClassElement classDecl) => classes.add(classDecl);
    dynamic accept(ElementVisitor visitor) => visitor.visitSourceElement(this);
    
    String toString() {
  
negative.code:     
    dynamic accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
    
    MethodElement(MethodDeclaration this.ast, ClassElement this.classDecl) {
      _name = new Name.FromIdentifier(this.ast.name);
    }
    
    String toString() {
      return "Method [${isAbstract ? ' abstract ' : ''}"+
  