compiler/java/com/google/dart/compiler/resolver/ClassElementImplementation.java - sdk.git - Git at Google

 // Copyright (c) 2012, 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.

 package com.google.dart.compiler.resolver;

 import com.google.common.collect.Lists;
 import com.google.dart.compiler.ast.ASTNodes;
 import com.google.dart.compiler.ast.DartClass;
 import com.google.dart.compiler.ast.DartClassTypeAlias;
 import com.google.dart.compiler.ast.DartDeclaration;
 import com.google.dart.compiler.ast.DartIdentifier;
 import com.google.dart.compiler.ast.DartObsoleteMetadata;
 import com.google.dart.compiler.ast.DartStringLiteral;
 import com.google.dart.compiler.ast.DartTypeParameter;
 import com.google.dart.compiler.ast.Modifiers;
 import com.google.dart.compiler.common.SourceInfo;
 import com.google.dart.compiler.type.InterfaceType;
 import com.google.dart.compiler.type.Type;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicReference;

 class ClassElementImplementation extends AbstractNodeElement implements ClassNodeElement {
   private InterfaceType type;
   private InterfaceType supertype;
   private InterfaceType defaultClass;
   private final List<InterfaceType> interfaces = Lists.newArrayList();
   private final List<InterfaceType> mixins = Lists.newArrayList();
   private final boolean isInterface;
   private final String nativeName;
   private final DartObsoleteMetadata metadata;
   private final Modifiers modifiers;
   private final AtomicReference<List<InterfaceType>> allSupertypes =
       new AtomicReference<List<InterfaceType>>();
   private final SourceInfo nameLocation;
   private final String declarationNameWithTypeParameter;
   private List<Element> unimplementedMembers;
   private final int openBraceOffset;
   private final int closeBraceOffset;
   private final boolean hasSuperInvocation;

   // declared volatile for thread-safety
   @SuppressWarnings("unused")
   private volatile Set<InterfaceType> subtypes;

   private final List<ConstructorNodeElement> constructors = Lists.newArrayList();
   private final ElementMap members = new ElementMap();

   private final LibraryElement library;

   private static ThreadLocal<Set<Element>> seenSupertypes = new ThreadLocal<Set<Element>>() {
     @Override
     protected Set<Element> initialValue() {
       return new HashSet<Element>();
     }
   };

   ClassElementImplementation(DartClass node, String name, String nativeName,
                              LibraryElement library) {
     super(node, name);
     this.nativeName = nativeName;
     this.library = library;
     if (node != null) {
       isInterface = node.isInterface();
       metadata = node.getObsoleteMetadata();
       modifiers = node.getModifiers();
       nameLocation = node.getName().getSourceInfo();
       declarationNameWithTypeParameter = createDeclarationName(node.getName(), node.getTypeParameters());
       openBraceOffset = node.getOpenBraceOffset();
       closeBraceOffset = node.getCloseBraceOffset();
       hasSuperInvocation = ASTNodes.hasSuperInvocation(node);
     } else {
       isInterface = false;
       metadata = DartObsoleteMetadata.EMPTY;
       modifiers = Modifiers.NONE;
       nameLocation = SourceInfo.UNKNOWN;
       declarationNameWithTypeParameter = "";
       openBraceOffset = -1;
       closeBraceOffset = -1;
       hasSuperInvocation = false;
     }
   }

   ClassElementImplementation(DartClassTypeAlias node, String name,
       LibraryElement library) {
     super(node, name);
     this.nativeName = null;
     this.library = library;
     if (node != null) {
       isInterface = false;
       metadata = node.getObsoleteMetadata();
       modifiers = node.getModifiers();
       nameLocation = node.getName().getSourceInfo();
       declarationNameWithTypeParameter = createDeclarationName(node.getName(), node.getTypeParameters());
       openBraceOffset = -1;
       closeBraceOffset = -1;
       hasSuperInvocation = false;
     } else {
       isInterface = false;
       metadata = DartObsoleteMetadata.EMPTY;
       modifiers = Modifiers.NONE;
       nameLocation = SourceInfo.UNKNOWN;
       declarationNameWithTypeParameter = "";
       openBraceOffset = -1;
       closeBraceOffset = -1;
       hasSuperInvocation = false;
     }
   }

   @Override
   public DartDeclaration<?> getNode() {
     return (DartDeclaration<?>) super.getNode();
   }

   @Override
   public SourceInfo getNameLocation() {
     return nameLocation;
   }

   @Override
   public void setType(InterfaceType type) {
     this.type = type;
   }

   @Override
   public InterfaceType getType() {
     return type;
   }

   @Override
   public List<Type> getTypeParameters() {
     return getType().getArguments();
   }

   @Override
   public InterfaceType getSupertype() {
     return supertype;
   }

   @Override
   public InterfaceType getDefaultClass() {
     return defaultClass;
   }

   @Override
   public void setSupertype(InterfaceType supertype) {
     if (this.supertype != null) {
       this.supertype.unregisterSubClass(this);
     }
     this.supertype = supertype;
     if (this.supertype != null) {
       this.supertype.registerSubClass(this);
     }
   }

   void setDefaultClass(InterfaceType element) {
     defaultClass = element;
   }

   @Override
   public Iterable<NodeElement> getMembers() {
     return new Iterable<NodeElement>() {
       // The only use case for calling getMembers() is for iterating through the
       // members. You should not be able to add or remove members through the
       // object returned by this method. Returning members or members.value()
       // would allow such direct manipulation which might be problematic for
       // keeping the element model consistent.
       //
       // On the other hand, we don't want to make a defensive copy of the list
       // because that makes this method expensive. This method should not be
       // expensive because the IDE may be using it in interactive scenarios.
       // Strictly speaking, we should also wrap the iterator as we don't want
       // the method Iterator.remove to be used either.
       @Override
       public Iterator<NodeElement> iterator() {
         return members.values().iterator();
       }
     };
   }

   @Override
   public List<ConstructorNodeElement> getConstructors() {
     return constructors;
   }

   @Override
   public List<InterfaceType> getInterfaces() {
     return interfaces;
   }

   @Override
   public List<InterfaceType> getMixins() {
     return mixins;
   }

   @Override
   public ElementKind getKind() {
     return ElementKind.CLASS;
   }

   @Override
   public boolean isInterface() {
     return isInterface;
   }

   @Override
   public DartObsoleteMetadata getMetadata() {
     return metadata;
   }

   @Override
   public Modifiers getModifiers() {
     return modifiers;
   }

   @Override
   public LibraryElement getLibrary() {
     return library;
   }

   @Override
   public String getNativeName() {
     return nativeName;
   }

   @Override
   public String getDeclarationNameWithTypeParameters() {
     return declarationNameWithTypeParameter;
   }

   void addMethod(MethodNodeElement member) {
     String name = member.getName();
     if (member.getModifiers().isOperator()) {
       name = "operator " + name;
     }
     members.add(name, member);
   }

   void addConstructor(ConstructorNodeElement member) {
     constructors.add(member);
   }

   void addField(FieldNodeElement member) {
     members.add(member.getName(), member);
   }

   void addInterface(InterfaceType type) {
     interfaces.add(type);
     type.registerSubClass(this);
   }

   void addMixin(InterfaceType type) {
     mixins.add(type);
   }

   Element findElement(String name) {
     // Temporary find all strategy to get things working.
     // Match resolve order in Resolver.visitMethodInvocation
     Element element = lookupLocalMethod(name);
     if (element != null) {
       return element;
     }
     element = lookupLocalField(name);
     if (element != null) {
       return element;
     }
     if (type != null) {
       for (Type arg : type.getArguments()) {
         if (arg.getElement().getName().equals(name)) {
           return arg.getElement();
         }
       }
     }
     // Don't look for constructors, they are in a different namespace.
     return null;
   }

   /**
    * Lookup a constructor declared in this class. Note that a class may define
    * constructors for interfaces in case the class is a default implementation.
    *
    * @param type The type of the object this constructor is creating.
    * @param name The constructor name ("" if unnamed).
    *
    * @return The constructor found in the class, or null if not found.
    */
   ConstructorElement lookupConstructor(ClassElement type, String name) {
     for (ConstructorElement element : constructors) {
       if (element.getConstructorType().equals(type) && element.getName().equals(name)) {
         return element;
       }
     }
     return null;
   }

   @Override
   public ConstructorElement lookupConstructor(String name) {
     // Lookup a constructor that creates instances of this class.
     return lookupConstructor(this, name);
   }

   @Override
   public Element lookupLocalElement(String name) {
     return members.get(name);
   }

   FieldElement lookupLocalField(String name) {
     return (FieldElement) members.get(name, ElementKind.FIELD);
   }

   MethodElement lookupLocalMethod(String name) {
     return (MethodElement) members.get(name, ElementKind.METHOD);
   }

   public static ClassElementImplementation fromNode(DartClass node, LibraryElement library) {
     DartStringLiteral nativeName = node.getNativeName();
     String nativeNameString = (nativeName == null ? null : nativeName.getValue());
     return new ClassElementImplementation(node, node.getClassName(), nativeNameString, library);
   }

   static class ClassAliasElementImplementation extends ClassElementImplementation implements ClassAliasElement {
     ClassAliasElementImplementation(DartClassTypeAlias node, String name, LibraryElement library) {
       super(node, name, library);
     }
   }
   public static ClassAliasElement fromNode(DartClassTypeAlias node, LibraryElement library) {
     return new ClassAliasElementImplementation(node, node.getClassName(), library);
   }

   public static ClassElementImplementation named(String name) {
     return new ClassElementImplementation(null, name, null, null);
   }

   @Override
   public boolean isObject() {
     return supertype == null;
   }

   @Override
   public boolean isObjectChild() {
     return supertype != null && supertype.getElement().isObject();
   }

   @Override
   public EnclosingElement getEnclosingElement() {
     return library;
   }

   @Override
   public List<InterfaceType> getAllSupertypes()
       throws CyclicDeclarationException {
     List<InterfaceType> list = allSupertypes.get();
     if (list == null) {
       allSupertypes.compareAndSet(null, computeAllSupertypes());
       list = allSupertypes.get();
     }
     return list;
   }

   private List<InterfaceType> computeAllSupertypes()
       throws CyclicDeclarationException {
     Map<ClassElement, InterfaceType> interfaces = new HashMap<ClassElement, InterfaceType>();
     if (!seenSupertypes.get().add(this)) {
       throw new CyclicDeclarationException(this);
     }
     ArrayList<InterfaceType> supertypes = new ArrayList<InterfaceType>();
     try {
       for (InterfaceType intf : getInterfaces()) {
         addInterfaceToSupertypes(interfaces, supertypes, intf);
       }
       for (InterfaceType mix : getMixins()) {
         addInterfaceToSupertypes(interfaces, supertypes, mix);
       }
       for (InterfaceType intf : getInterfaces()) {
         for (InterfaceType t : intf.getElement().getAllSupertypes()) {
           if (!t.getElement().isObject()) {
             addInterfaceToSupertypes(interfaces, supertypes,
                                t.subst(intf.getArguments(),
                                        intf.getElement().getTypeParameters()));
           }
         }
       }
       if (supertype != null) {
         for (InterfaceType t : supertype.getElement().getAllSupertypes()) {
           if (t.getElement().isInterface()) {
             addInterfaceToSupertypes(interfaces, supertypes,
                                t.subst(supertype.getArguments(),
                                        supertype.getElement().getTypeParameters()));
           }
         }
         supertypes.add(supertype);
         for (InterfaceType t : supertype.getElement().getAllSupertypes()) {
           if (!t.getElement().isInterface()) {
             supertypes.add(t.subst(supertype.getArguments(),
                                    supertype.getElement().getTypeParameters()));
           }
         }
       }
     } finally {
       seenSupertypes.get().remove(this);
     }
     return supertypes;
   }

   private String createDeclarationName(
       DartIdentifier name, List<DartTypeParameter> typeParameters) {
     StringBuilder builder = new StringBuilder();
     builder.append(name.toSource());
     int count = typeParameters.size();
     if (count > 0) {
       builder.append("<");
       for (int i = 0; i < count; i++) {
         if (i > 0) {
           builder.append(", ");
         }
         builder.append(typeParameters.get(i).toSource());
       }
       builder.append(">");
     }
     return builder.toString();
   }

   private void addInterfaceToSupertypes(Map<ClassElement, InterfaceType> interfaces,
                                   ArrayList<InterfaceType> supertypes,
                                   InterfaceType intf) {
     InterfaceType existing = interfaces.put(intf.getElement(), intf);
     if (existing == null || !(existing.equals(intf))){
       supertypes.add(intf);
     }
   }

   @Override
   public List<Element> getUnimplementedMembers() {
     return unimplementedMembers;
   }

   @Override
   public void setUnimplementedMembers(List<Element> members) {
     this.unimplementedMembers = members;
   }

   @Override
   public int getOpenBraceOffset() {
     return openBraceOffset;
   }

   @Override
   public int getCloseBraceOffset() {
     return closeBraceOffset;
   }

   @Override
   public boolean hasSuperInvocation() {
     return hasSuperInvocation;
   }
 }
	// Copyright (c) 2012, 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.

	package com.google.dart.compiler.resolver;

	import com.google.common.collect.Lists;
	import com.google.dart.compiler.ast.ASTNodes;
	import com.google.dart.compiler.ast.DartClass;
	import com.google.dart.compiler.ast.DartClassTypeAlias;
	import com.google.dart.compiler.ast.DartDeclaration;
	import com.google.dart.compiler.ast.DartIdentifier;
	import com.google.dart.compiler.ast.DartObsoleteMetadata;
	import com.google.dart.compiler.ast.DartStringLiteral;
	import com.google.dart.compiler.ast.DartTypeParameter;
	import com.google.dart.compiler.ast.Modifiers;
	import com.google.dart.compiler.common.SourceInfo;
	import com.google.dart.compiler.type.InterfaceType;
	import com.google.dart.compiler.type.Type;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.concurrent.atomic.AtomicReference;

	class ClassElementImplementation extends AbstractNodeElement implements ClassNodeElement {
	private InterfaceType type;
	private InterfaceType supertype;
	private InterfaceType defaultClass;
	private final List<InterfaceType> interfaces = Lists.newArrayList();
	private final List<InterfaceType> mixins = Lists.newArrayList();
	private final boolean isInterface;
	private final String nativeName;
	private final DartObsoleteMetadata metadata;
	private final Modifiers modifiers;
	private final AtomicReference<List<InterfaceType>> allSupertypes =
	new AtomicReference<List<InterfaceType>>();
	private final SourceInfo nameLocation;
	private final String declarationNameWithTypeParameter;
	private List<Element> unimplementedMembers;
	private final int openBraceOffset;
	private final int closeBraceOffset;
	private final boolean hasSuperInvocation;

	// declared volatile for thread-safety
	@SuppressWarnings("unused")
	private volatile Set<InterfaceType> subtypes;

	private final List<ConstructorNodeElement> constructors = Lists.newArrayList();
	private final ElementMap members = new ElementMap();

	private final LibraryElement library;

	private static ThreadLocal<Set<Element>> seenSupertypes = new ThreadLocal<Set<Element>>() {
	@Override
	protected Set<Element> initialValue() {
	return new HashSet<Element>();
	}
	};

	ClassElementImplementation(DartClass node, String name, String nativeName,
	LibraryElement library) {
	super(node, name);
	this.nativeName = nativeName;
	this.library = library;
	if (node != null) {
	isInterface = node.isInterface();
	metadata = node.getObsoleteMetadata();
	modifiers = node.getModifiers();
	nameLocation = node.getName().getSourceInfo();
	declarationNameWithTypeParameter = createDeclarationName(node.getName(), node.getTypeParameters());
	openBraceOffset = node.getOpenBraceOffset();
	closeBraceOffset = node.getCloseBraceOffset();
	hasSuperInvocation = ASTNodes.hasSuperInvocation(node);
	} else {
	isInterface = false;
	metadata = DartObsoleteMetadata.EMPTY;
	modifiers = Modifiers.NONE;
	nameLocation = SourceInfo.UNKNOWN;
	declarationNameWithTypeParameter = "";
	openBraceOffset = -1;
	closeBraceOffset = -1;
	hasSuperInvocation = false;
	}
	}

	ClassElementImplementation(DartClassTypeAlias node, String name,
	LibraryElement library) {
	super(node, name);
	this.nativeName = null;
	this.library = library;
	if (node != null) {
	isInterface = false;
	metadata = node.getObsoleteMetadata();
	modifiers = node.getModifiers();
	nameLocation = node.getName().getSourceInfo();
	declarationNameWithTypeParameter = createDeclarationName(node.getName(), node.getTypeParameters());
	openBraceOffset = -1;
	closeBraceOffset = -1;
	hasSuperInvocation = false;
	} else {
	isInterface = false;
	metadata = DartObsoleteMetadata.EMPTY;
	modifiers = Modifiers.NONE;
	nameLocation = SourceInfo.UNKNOWN;
	declarationNameWithTypeParameter = "";
	openBraceOffset = -1;
	closeBraceOffset = -1;
	hasSuperInvocation = false;
	}
	}

	@Override
	public DartDeclaration<?> getNode() {
	return (DartDeclaration<?>) super.getNode();
	}

	@Override
	public SourceInfo getNameLocation() {
	return nameLocation;
	}

	@Override
	public void setType(InterfaceType type) {
	this.type = type;
	}

	@Override
	public InterfaceType getType() {
	return type;
	}

	@Override
	public List<Type> getTypeParameters() {
	return getType().getArguments();
	}

	@Override
	public InterfaceType getSupertype() {
	return supertype;
	}

	@Override
	public InterfaceType getDefaultClass() {
	return defaultClass;
	}

	@Override
	public void setSupertype(InterfaceType supertype) {
	if (this.supertype != null) {
	this.supertype.unregisterSubClass(this);
	}
	this.supertype = supertype;
	if (this.supertype != null) {
	this.supertype.registerSubClass(this);
	}
	}

	void setDefaultClass(InterfaceType element) {
	defaultClass = element;
	}

	@Override
	public Iterable<NodeElement> getMembers() {
	return new Iterable<NodeElement>() {
	// The only use case for calling getMembers() is for iterating through the
	// members. You should not be able to add or remove members through the
	// object returned by this method. Returning members or members.value()
	// would allow such direct manipulation which might be problematic for
	// keeping the element model consistent.
	//
	// On the other hand, we don't want to make a defensive copy of the list
	// because that makes this method expensive. This method should not be
	// expensive because the IDE may be using it in interactive scenarios.
	// Strictly speaking, we should also wrap the iterator as we don't want
	// the method Iterator.remove to be used either.
	@Override
	public Iterator<NodeElement> iterator() {
	return members.values().iterator();
	}
	};
	}

	@Override
	public List<ConstructorNodeElement> getConstructors() {
	return constructors;
	}

	@Override
	public List<InterfaceType> getInterfaces() {
	return interfaces;
	}

	@Override
	public List<InterfaceType> getMixins() {
	return mixins;
	}

	@Override
	public ElementKind getKind() {
	return ElementKind.CLASS;
	}

	@Override
	public boolean isInterface() {
	return isInterface;
	}

	@Override
	public DartObsoleteMetadata getMetadata() {
	return metadata;
	}

	@Override
	public Modifiers getModifiers() {
	return modifiers;
	}

	@Override
	public LibraryElement getLibrary() {
	return library;
	}

	@Override
	public String getNativeName() {
	return nativeName;
	}

	@Override
	public String getDeclarationNameWithTypeParameters() {
	return declarationNameWithTypeParameter;
	}

	void addMethod(MethodNodeElement member) {
	String name = member.getName();
	if (member.getModifiers().isOperator()) {
	name = "operator " + name;
	}
	members.add(name, member);
	}

	void addConstructor(ConstructorNodeElement member) {
	constructors.add(member);
	}

	void addField(FieldNodeElement member) {
	members.add(member.getName(), member);
	}

	void addInterface(InterfaceType type) {
	interfaces.add(type);
	type.registerSubClass(this);
	}

	void addMixin(InterfaceType type) {
	mixins.add(type);
	}

	Element findElement(String name) {
	// Temporary find all strategy to get things working.
	// Match resolve order in Resolver.visitMethodInvocation
	Element element = lookupLocalMethod(name);
	if (element != null) {
	return element;
	}
	element = lookupLocalField(name);
	if (element != null) {
	return element;
	}
	if (type != null) {
	for (Type arg : type.getArguments()) {
	if (arg.getElement().getName().equals(name)) {
	return arg.getElement();
	}
	}
	}
	// Don't look for constructors, they are in a different namespace.
	return null;
	}

	/**
	* Lookup a constructor declared in this class. Note that a class may define
	* constructors for interfaces in case the class is a default implementation.
	*
	* @param type The type of the object this constructor is creating.
	* @param name The constructor name ("" if unnamed).
	*
	* @return The constructor found in the class, or null if not found.
	*/
	ConstructorElement lookupConstructor(ClassElement type, String name) {
	for (ConstructorElement element : constructors) {
	if (element.getConstructorType().equals(type) && element.getName().equals(name)) {
	return element;
	}
	}
	return null;
	}

	@Override
	public ConstructorElement lookupConstructor(String name) {
	// Lookup a constructor that creates instances of this class.
	return lookupConstructor(this, name);
	}

	@Override
	public Element lookupLocalElement(String name) {
	return members.get(name);
	}

	FieldElement lookupLocalField(String name) {
	return (FieldElement) members.get(name, ElementKind.FIELD);
	}

	MethodElement lookupLocalMethod(String name) {
	return (MethodElement) members.get(name, ElementKind.METHOD);
	}

	public static ClassElementImplementation fromNode(DartClass node, LibraryElement library) {
	DartStringLiteral nativeName = node.getNativeName();
	String nativeNameString = (nativeName == null ? null : nativeName.getValue());
	return new ClassElementImplementation(node, node.getClassName(), nativeNameString, library);
	}

	static class ClassAliasElementImplementation extends ClassElementImplementation implements ClassAliasElement {
	ClassAliasElementImplementation(DartClassTypeAlias node, String name, LibraryElement library) {
	super(node, name, library);
	}
	}
	public static ClassAliasElement fromNode(DartClassTypeAlias node, LibraryElement library) {
	return new ClassAliasElementImplementation(node, node.getClassName(), library);
	}

	public static ClassElementImplementation named(String name) {
	return new ClassElementImplementation(null, name, null, null);
	}

	@Override
	public boolean isObject() {
	return supertype == null;
	}

	@Override
	public boolean isObjectChild() {
	return supertype != null && supertype.getElement().isObject();
	}

	@Override
	public EnclosingElement getEnclosingElement() {
	return library;
	}

	@Override
	public List<InterfaceType> getAllSupertypes()
	throws CyclicDeclarationException {
	List<InterfaceType> list = allSupertypes.get();
	if (list == null) {
	allSupertypes.compareAndSet(null, computeAllSupertypes());
	list = allSupertypes.get();
	}
	return list;
	}

	private List<InterfaceType> computeAllSupertypes()
	throws CyclicDeclarationException {
	Map<ClassElement, InterfaceType> interfaces = new HashMap<ClassElement, InterfaceType>();
	if (!seenSupertypes.get().add(this)) {
	throw new CyclicDeclarationException(this);
	}
	ArrayList<InterfaceType> supertypes = new ArrayList<InterfaceType>();
	try {
	for (InterfaceType intf : getInterfaces()) {
	addInterfaceToSupertypes(interfaces, supertypes, intf);
	}
	for (InterfaceType mix : getMixins()) {
	addInterfaceToSupertypes(interfaces, supertypes, mix);
	}
	for (InterfaceType intf : getInterfaces()) {
	for (InterfaceType t : intf.getElement().getAllSupertypes()) {
	if (!t.getElement().isObject()) {
	addInterfaceToSupertypes(interfaces, supertypes,
	t.subst(intf.getArguments(),
	intf.getElement().getTypeParameters()));
	}
	}
	}
	if (supertype != null) {
	for (InterfaceType t : supertype.getElement().getAllSupertypes()) {
	if (t.getElement().isInterface()) {
	addInterfaceToSupertypes(interfaces, supertypes,
	t.subst(supertype.getArguments(),
	supertype.getElement().getTypeParameters()));
	}
	}
	supertypes.add(supertype);
	for (InterfaceType t : supertype.getElement().getAllSupertypes()) {
	if (!t.getElement().isInterface()) {
	supertypes.add(t.subst(supertype.getArguments(),
	supertype.getElement().getTypeParameters()));
	}
	}
	}
	} finally {
	seenSupertypes.get().remove(this);
	}
	return supertypes;
	}

	private String createDeclarationName(
	DartIdentifier name, List<DartTypeParameter> typeParameters) {
	StringBuilder builder = new StringBuilder();
	builder.append(name.toSource());
	int count = typeParameters.size();
	if (count > 0) {
	builder.append("<");
	for (int i = 0; i < count; i++) {
	if (i > 0) {
	builder.append(", ");
	}
	builder.append(typeParameters.get(i).toSource());
	}
	builder.append(">");
	}
	return builder.toString();
	}

	private void addInterfaceToSupertypes(Map<ClassElement, InterfaceType> interfaces,
	ArrayList<InterfaceType> supertypes,
	InterfaceType intf) {
	InterfaceType existing = interfaces.put(intf.getElement(), intf);
	if (existing == null \|\| !(existing.equals(intf))){
	supertypes.add(intf);
	}
	}

	@Override
	public List<Element> getUnimplementedMembers() {
	return unimplementedMembers;
	}

	@Override
	public void setUnimplementedMembers(List<Element> members) {
	this.unimplementedMembers = members;
	}

	@Override
	public int getOpenBraceOffset() {
	return openBraceOffset;
	}

	@Override
	public int getCloseBraceOffset() {
	return closeBraceOffset;
	}

	@Override
	public boolean hasSuperInvocation() {
	return hasSuperInvocation;
	}
	}