anchor.diff:  /**
    * Instances of a class`FunctionElement` is a our abstract representation of functions
    **/
  -class FunctionElement extends Block implements Element {
  +class FunctionElement extends Block with Element {
  +  FunctionExpression ast;
     SourceElement sourceElement;
  -  FunctionDeclaration ast;
  -  
  -  Source get library_source => sourceElement.library_source;
  -  
  -  String get name => isSetter ? setterName : getterName;
  -  String get getterName => ast.name.toString();
  -  String get setterName => FunctionElement.SetterName(getterName);
  -  bool get isGetter => ast.isGetter;
  -  bool get isSetter => ast.isSetter;
  +  
  +  
     bool get isSynthetic => ast.isSynthetic;
     
  -  static String SetterName(String name) => name + "=";
  -  static String UnaryMinusName = 'unary-';
   
     dynamic accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
     
  -  FunctionElement(FunctionDeclaration this.ast, SourceElement this.sourceElement);
  +  FunctionElement(FunctionExpression this.ast, SourceElement this.sourceElement);
     
     String toString(){
  -    return "Func [${isGetter ? ' getter ' : ''}"+
  -            "${isSetter ? ' setter ' : ''}"+
  -            "${isSynthetic ? ' synthetic ' : ''}] ${ast.returnType} ${name}(${ast.functionExpression.parameters})";
  +    return "Func [${isSynthetic ? ' synthetic ' : ''}] annonymous";
  +  }
  +}
  +
  +class NamedFunctionElement extends FunctionElement implements NamedElement {
  +  FunctionDeclaration decl;
  +  Name _name;
  +  Name get setterName => Name.SetterName(_name);
  +  Name get getterName => _name;
  +  bool get isPrivate => _name.isPrivate; 
  +  Name get name => isSetter ? setterName : getterName;
  +  bool get isGetter => decl.isGetter;
  +  bool get isSetter => decl.isSetter;
  +  
  +  NamedFunctionElement(FunctionDeclaration decl, SourceElement sourceElement) : super(decl.functionExpression, sourceElement) {
  +    _name = new Name.FromIdentifier(decl.name);
     }
   }
   
  
positive.code: /**
   * Instances of a class `ConstructorElement` is a our abstract representation of constructors
   **/
  class ConstructorElement extends ClassMember with Block implements Element {
    ConstructorDeclaration ast;
    
    String get name => ast.name.toString();
    bool get isSynthetic => ast.isSynthetic;
    bool get isFactory => ast.factoryKeyword != null;
    bool get isExternal => ast.externalKeyword != null;
      
    dynamic accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
  
    ConstructorElement(ConstructorDeclaration this.ast, ClassElement classDecl): super(classDecl);
    
    String toString() {
      return "Constructor [${isFactory ? ' factory ' : ''}"+
  
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 ' : ''}"+
  