pkg/analyzer/lib/src/error/inheritance_override.dart - sdk - Git at Google

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

 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/type_system.dart';

 class InheritanceOverrideVerifier {
   final StrongTypeSystemImpl _typeSystem;
   final ErrorReporter _reporter;

   /// Cached instance interfaces for [InterfaceType].
   final Map<InterfaceType, _Interface> _interfaces = {};

   InheritanceOverrideVerifier(this._typeSystem, this._reporter);

   void verifyUnit(CompilationUnit unit) {
     for (var declaration in unit.declarations) {
       if (declaration is ClassDeclaration) {
         _verifyClass(declaration.name,
             withClause: declaration.withClause, members: declaration.members);
       } else if (declaration is ClassTypeAlias) {
         _verifyClass(declaration.name, withClause: declaration.withClause);
       } else if (declaration is MixinDeclaration) {
         _verifyClass(declaration.name, members: declaration.members);
       }
     }
   }

   /// Check that the given [member] is a valid override of the corresponding
   /// instance members in each of [allSuperinterfaces].
   void _checkDeclaredMember(
     List<InterfaceType> allSuperinterfaces,
     AstNode node,
     ExecutableElement member,
   ) {
     if (member == null) return;
     if (member.isStatic) return;

     var name = member.name;
     for (var supertype in allSuperinterfaces) {
       var superMember = _getInstanceMember(supertype, name);
       if (superMember != null && superMember.isAccessibleIn(member.library)) {
         // The case when members have different kinds is reported in verifier.
         if (member.kind != superMember.kind) {
           continue;
         }

         if (!_typeSystem.isOverrideSubtypeOf(member.type, superMember.type)) {
           _reporter.reportErrorForNode(
             CompileTimeErrorCode.INVALID_OVERRIDE,
             node,
             [
               name,
               member.enclosingElement.name,
               member.type.displayName,
               superMember.enclosingElement.name,
               superMember.type.displayName
             ],
           );
         }
       }
     }
   }

   /// Check that instance members of [type] are valid overrides of the
   /// corresponding instance members in each of [allSuperinterfaces].
   void _checkDeclaredMembers(
     List<InterfaceType> allSuperinterfaces,
     AstNode node,
     InterfaceTypeImpl type,
   ) {
     for (var method in type.methods) {
       _checkDeclaredMember(allSuperinterfaces, node, method);
     }
     for (var accessor in type.accessors) {
       _checkDeclaredMember(allSuperinterfaces, node, accessor);
     }
   }

   /// Return the instance member given the [name], defined in the [type],
   /// or `null` if the [type] does not define a member with the [name], or
   /// if it is not an instance member.
   ExecutableElement _getInstanceMember(InterfaceType type, String name) {
     ExecutableElement result;
     if (name.endsWith('=')) {
       name = name.substring(0, name.length - 1);
       result = type.getSetter(name);
     } else {
       result = type.getMethod(name) ?? type.getGetter(name);
     }
     if (result != null && result.isStatic) {
       result = null;
     }
     return result;
   }

   /// Return the interface of the given [type], for the [consumerLibrary].
   _Interface _getInterface(InterfaceType type, LibraryElement consumerLibrary) {
     if (type == null) return new _Interface({}, []);

     var result = _interfaces[type];
     if (result != null) return result;

     var map = <String, FunctionType>{};
     var conflicts = <_Conflict>[];
     _interfaces[type] = new _Interface(map, conflicts);

     // If a class declaration has a member declaration, the signature of that
     // member declaration becomes the signature in the interface.
     {
       void addTypeMember(ExecutableElement member) {
         if (member.isAccessibleIn(consumerLibrary) && !member.isStatic) {
           map[member.name] = member.type;
         }
       }

       type.methods.forEach(addTypeMember);
       type.accessors.forEach(addTypeMember);
     }

     var inheritedCandidates = <String, List<FunctionType>>{};
     void addSuperinterfaceMember(String name, FunctionType candidate) {
       // If name is in the [map], then it is defined in the [type] itself.
       // Don't consider candidates from direct superinterfaces.
       // The version defined in the type might be invalid, we check elsewhere.
       if (map.containsKey(name)) return;

       var candidates = inheritedCandidates[name];
       if (candidates == null) {
         candidates = <FunctionType>[];
         inheritedCandidates[name] = candidates;
       }
       candidates.add(candidate);
     }

     var library = type.element.library;
     void addSuperinterfaceMembers(InterfaceType superinterface) {
       _getInterface(superinterface, library)
           .map
           .forEach(addSuperinterfaceMember);
     }

     // Fill candidates for each instance name.
     addSuperinterfaceMembers(type.superclass);
     type.superclassConstraints.forEach(addSuperinterfaceMembers);
     type.mixins.forEach(addSuperinterfaceMembers);
     type.interfaces.forEach(addSuperinterfaceMembers);

     // If a class declaration does not have a member declaration with a
     // particular name, but some super-interfaces do have a member with that
     // name, it's a compile-time error if there is no signature among the
     // super-interfaces that is a valid override of all the other
     // super-interface signatures with the same name. That "most specific"
     // signature becomes the signature of the class's interface.
     for (var name in inheritedCandidates.keys) {
       var candidates = inheritedCandidates[name];

       bool allGetters = true;
       bool allMethods = true;
       bool allSetters = true;
       for (var candidate in candidates) {
         var kind = candidate.element.kind;
         if (kind != ElementKind.GETTER) {
           allGetters = false;
         }
         if (kind != ElementKind.METHOD) {
           allMethods = false;
         }
         if (kind != ElementKind.SETTER) {
           allSetters = false;
         }
       }

       if (allSetters) {
         // OK, setters don't conflict with anything.
       } else if (!(allGetters || allMethods)) {
         FunctionType getterType;
         FunctionType methodType;
         for (var candidate in candidates) {
           var kind = candidate.element.kind;
           if (kind == ElementKind.GETTER) {
             getterType ??= candidate;
           }
           if (kind == ElementKind.METHOD) {
             methodType ??= candidate;
           }
         }
         conflicts.add(new _Conflict(name, candidates, getterType, methodType));
         continue;
       }

       FunctionType validOverride;
       for (var i = 0; i < candidates.length; i++) {
         validOverride = candidates[i];
         for (var j = 0; j < candidates.length; j++) {
           var candidate = candidates[j];
           if (!_typeSystem.isOverrideSubtypeOf(validOverride, candidate)) {
             validOverride = null;
             break;
           }
         }
         if (validOverride != null) {
           break;
         }
       }

       if (validOverride != null) {
         map[name] = validOverride;
       } else {
         conflicts.add(new _Conflict(name, candidates));
       }
     }

     return new _Interface(map, conflicts);
   }

   void _reportInconsistentInheritance(AstNode node, _Conflict conflict) {
     var name = conflict.name;

     if (conflict.getter != null && conflict.method != null) {
       _reporter.reportErrorForNode(
         CompileTimeErrorCode.INCONSISTENT_INHERITANCE_GETTER_AND_METHOD,
         node,
         [
           name,
           conflict.getter.element.enclosingElement.name,
           conflict.method.element.enclosingElement.name
         ],
       );
     } else {
       var candidatesStr = conflict.candidates.map((candidate) {
         var className = candidate.element.enclosingElement.name;
         return '$className.$name (${candidate.displayName})';
       }).join(', ');

       _reporter.reportErrorForNode(
         CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
         node,
         [name, candidatesStr],
       );
     }
   }

   void _verifyClass(SimpleIdentifier classNameNode,
       {List<ClassMember> members: const [], WithClause withClause}) {
     ClassElementImpl element = classNameNode.staticElement;
     LibraryElement library = element.library;
     InterfaceTypeImpl type = element.type;

     var allSuperinterfaces = <InterfaceType>[];

     // Add all superinterfaces of the direct supertype.
     if (type.superclass != null) {
       ClassElementImpl.collectAllSupertypes(
           allSuperinterfaces, type.superclass, null);
     }

     // Each mixin in `class C extends S with M0, M1, M2 {}` is equivalent to:
     //   class S&M0 extends S { ...members of M0... }
     //   class S&M1 extends S&M0 { ...members of M1... }
     //   class S&M2 extends S&M1 { ...members of M2... }
     //   class C extends S&M2 { ...members of C... }
     // So, we need to check members of each mixin against superinterfaces
     // of `S`, and superinterfaces of all previous mixins.
     var mixinNodes = withClause?.mixinTypes;
     var mixinTypes = type.mixins;
     for (var i = 0; i < mixinTypes.length; i++) {
       _checkDeclaredMembers(allSuperinterfaces, mixinNodes[i], mixinTypes[i]);
       ClassElementImpl.collectAllSupertypes(
           allSuperinterfaces, mixinTypes[i], null);
     }

     // Add all superinterfaces of the direct class interfaces.
     for (var interface in type.interfaces) {
       ClassElementImpl.collectAllSupertypes(
           allSuperinterfaces, interface, null);
     }

     // Check the members if the class itself, against all the previously
     // collected superinterfaces of the supertype, mixins, and interfaces.
     for (var member in members) {
       if (member is FieldDeclaration) {
         var fieldList = member.fields;
         for (var field in fieldList.variables) {
           FieldElement fieldElement = field.declaredElement;
           _checkDeclaredMember(
               allSuperinterfaces, fieldList, fieldElement.getter);
           _checkDeclaredMember(
               allSuperinterfaces, fieldList, fieldElement.setter);
         }
       } else if (member is MethodDeclaration) {
         _checkDeclaredMember(
             allSuperinterfaces, member, member.declaredElement);
       }
     }

     // Compute the interface of the class.
     var interfaceMembers = _getInterface(type, element.library);

     // Report conflicts between direct superinterfaces of the class.
     for (var conflict in interfaceMembers.conflicts) {
       _reportInconsistentInheritance(classNameNode, conflict);
     }

     // TODO(scheglov) isMixin must be also isAbstract.
     if (!element.isAbstract && !element.isMixin) {
       for (var name in interfaceMembers.map.keys) {
         var concreteElement = type.lookUpInheritedMember(name, library,
             concrete: true, thisType: true, setter: name.endsWith('='));

         // TODO(scheglov) handle here instead of ErrorVerifier?
         if (concreteElement == null) {
           continue;
         }
         // TODO(scheglov) Why InterfaceType even returns statics?
         if (concreteElement.isStatic) {
           continue;
         }

         var concreteType = concreteElement.type;
         var interfaceType = interfaceMembers.map[name];

         // The case when members have different kinds is reported in verifier.
         if (concreteType.element.kind != interfaceType.element.kind) {
           continue;
         }

         // If a class declaration is not abstract, and the interface has a
         // member declaration named `m`, then:
         // 1. if the class contains a non-overridden member whose signature is
         //    not a valid override of the interface member signature for `m`,
         //    then it's a compile-time error.
         // 2. if the class contains no member named `m`, and the class member
         //    for `noSuchMethod` is the one declared in `Object`, then it's a
         //    compile-time error. TODO(scheglov) implement this
         if (!_typeSystem.isOverrideSubtypeOf(concreteType, interfaceType)) {
           _reporter.reportErrorForNode(
             CompileTimeErrorCode.INVALID_OVERRIDE,
             classNameNode,
             [
               name,
               concreteElement.enclosingElement.name,
               concreteType.displayName,
               interfaceType.element.enclosingElement.name,
               interfaceType.displayName
             ],
           );
         }
       }
     }
   }
 }

 /// Description of a failure to find a valid override from superinterfaces.
 class _Conflict {
   /// The name of an instance member for which we failed to find a valid
   /// override.
   final String name;

   /// The list of candidates for a valid override for a member [name].  It has
   /// at least two items, because otherwise the only candidate is always valid.
   final List<FunctionType> candidates;

   final FunctionType getter;
   final FunctionType method;

   _Conflict(this.name, this.candidates, [this.getter, this.method]);
 }

 /// The instance interface of an [InterfaceType].
 class _Interface {
   final Map<String, FunctionType> map;
   final List<_Conflict> conflicts;

   _Interface(this.map, this.conflicts);
 }
	// Copyright (c) 2018, 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.

	import 'package:analyzer/analyzer.dart';
	import 'package:analyzer/dart/ast/ast.dart';
	import 'package:analyzer/dart/element/element.dart';
	import 'package:analyzer/dart/element/type.dart';
	import 'package:analyzer/error/listener.dart';
	import 'package:analyzer/src/dart/element/element.dart';
	import 'package:analyzer/src/dart/element/type.dart';
	import 'package:analyzer/src/error/codes.dart';
	import 'package:analyzer/src/generated/type_system.dart';

	class InheritanceOverrideVerifier {
	final StrongTypeSystemImpl _typeSystem;
	final ErrorReporter _reporter;

	/// Cached instance interfaces for [InterfaceType].
	final Map<InterfaceType, _Interface> _interfaces = {};

	InheritanceOverrideVerifier(this._typeSystem, this._reporter);

	void verifyUnit(CompilationUnit unit) {
	for (var declaration in unit.declarations) {
	if (declaration is ClassDeclaration) {
	_verifyClass(declaration.name,
	withClause: declaration.withClause, members: declaration.members);
	} else if (declaration is ClassTypeAlias) {
	_verifyClass(declaration.name, withClause: declaration.withClause);
	} else if (declaration is MixinDeclaration) {
	_verifyClass(declaration.name, members: declaration.members);
	}
	}
	}

	/// Check that the given [member] is a valid override of the corresponding
	/// instance members in each of [allSuperinterfaces].
	void _checkDeclaredMember(
	List<InterfaceType> allSuperinterfaces,
	AstNode node,
	ExecutableElement member,
	) {
	if (member == null) return;
	if (member.isStatic) return;

	var name = member.name;
	for (var supertype in allSuperinterfaces) {
	var superMember = _getInstanceMember(supertype, name);
	if (superMember != null && superMember.isAccessibleIn(member.library)) {
	// The case when members have different kinds is reported in verifier.
	if (member.kind != superMember.kind) {
	continue;
	}

	if (!_typeSystem.isOverrideSubtypeOf(member.type, superMember.type)) {
	_reporter.reportErrorForNode(
	CompileTimeErrorCode.INVALID_OVERRIDE,
	node,
	[
	name,
	member.enclosingElement.name,
	member.type.displayName,
	superMember.enclosingElement.name,
	superMember.type.displayName
	],
	);
	}
	}
	}
	}

	/// Check that instance members of [type] are valid overrides of the
	/// corresponding instance members in each of [allSuperinterfaces].
	void _checkDeclaredMembers(
	List<InterfaceType> allSuperinterfaces,
	AstNode node,
	InterfaceTypeImpl type,
	) {
	for (var method in type.methods) {
	_checkDeclaredMember(allSuperinterfaces, node, method);
	}
	for (var accessor in type.accessors) {
	_checkDeclaredMember(allSuperinterfaces, node, accessor);
	}
	}

	/// Return the instance member given the [name], defined in the [type],
	/// or `null` if the [type] does not define a member with the [name], or
	/// if it is not an instance member.
	ExecutableElement _getInstanceMember(InterfaceType type, String name) {
	ExecutableElement result;
	if (name.endsWith('=')) {
	name = name.substring(0, name.length - 1);
	result = type.getSetter(name);
	} else {
	result = type.getMethod(name) ?? type.getGetter(name);
	}
	if (result != null && result.isStatic) {
	result = null;
	}
	return result;
	}

	/// Return the interface of the given [type], for the [consumerLibrary].
	_Interface _getInterface(InterfaceType type, LibraryElement consumerLibrary) {
	if (type == null) return new _Interface({}, []);

	var result = _interfaces[type];
	if (result != null) return result;

	var map = <String, FunctionType>{};
	var conflicts = <_Conflict>[];
	_interfaces[type] = new _Interface(map, conflicts);

	// If a class declaration has a member declaration, the signature of that
	// member declaration becomes the signature in the interface.
	{
	void addTypeMember(ExecutableElement member) {
	if (member.isAccessibleIn(consumerLibrary) && !member.isStatic) {
	map[member.name] = member.type;
	}
	}

	type.methods.forEach(addTypeMember);
	type.accessors.forEach(addTypeMember);
	}

	var inheritedCandidates = <String, List<FunctionType>>{};
	void addSuperinterfaceMember(String name, FunctionType candidate) {
	// If name is in the [map], then it is defined in the [type] itself.
	// Don't consider candidates from direct superinterfaces.
	// The version defined in the type might be invalid, we check elsewhere.
	if (map.containsKey(name)) return;

	var candidates = inheritedCandidates[name];
	if (candidates == null) {
	candidates = <FunctionType>[];
	inheritedCandidates[name] = candidates;
	}
	candidates.add(candidate);
	}

	var library = type.element.library;
	void addSuperinterfaceMembers(InterfaceType superinterface) {
	_getInterface(superinterface, library)
	.map
	.forEach(addSuperinterfaceMember);
	}

	// Fill candidates for each instance name.
	addSuperinterfaceMembers(type.superclass);
	type.superclassConstraints.forEach(addSuperinterfaceMembers);
	type.mixins.forEach(addSuperinterfaceMembers);
	type.interfaces.forEach(addSuperinterfaceMembers);

	// If a class declaration does not have a member declaration with a
	// particular name, but some super-interfaces do have a member with that
	// name, it's a compile-time error if there is no signature among the
	// super-interfaces that is a valid override of all the other
	// super-interface signatures with the same name. That "most specific"
	// signature becomes the signature of the class's interface.
	for (var name in inheritedCandidates.keys) {
	var candidates = inheritedCandidates[name];

	bool allGetters = true;
	bool allMethods = true;
	bool allSetters = true;
	for (var candidate in candidates) {
	var kind = candidate.element.kind;
	if (kind != ElementKind.GETTER) {
	allGetters = false;
	}
	if (kind != ElementKind.METHOD) {
	allMethods = false;
	}
	if (kind != ElementKind.SETTER) {
	allSetters = false;
	}
	}

	if (allSetters) {
	// OK, setters don't conflict with anything.
	} else if (!(allGetters \|\| allMethods)) {
	FunctionType getterType;
	FunctionType methodType;
	for (var candidate in candidates) {
	var kind = candidate.element.kind;
	if (kind == ElementKind.GETTER) {
	getterType ??= candidate;
	}
	if (kind == ElementKind.METHOD) {
	methodType ??= candidate;
	}
	}
	conflicts.add(new _Conflict(name, candidates, getterType, methodType));
	continue;
	}

	FunctionType validOverride;
	for (var i = 0; i < candidates.length; i++) {
	validOverride = candidates[i];
	for (var j = 0; j < candidates.length; j++) {
	var candidate = candidates[j];
	if (!_typeSystem.isOverrideSubtypeOf(validOverride, candidate)) {
	validOverride = null;
	break;
	}
	}
	if (validOverride != null) {
	break;
	}
	}

	if (validOverride != null) {
	map[name] = validOverride;
	} else {
	conflicts.add(new _Conflict(name, candidates));
	}
	}

	return new _Interface(map, conflicts);
	}

	void _reportInconsistentInheritance(AstNode node, _Conflict conflict) {
	var name = conflict.name;

	if (conflict.getter != null && conflict.method != null) {
	_reporter.reportErrorForNode(
	CompileTimeErrorCode.INCONSISTENT_INHERITANCE_GETTER_AND_METHOD,
	node,
	[
	name,
	conflict.getter.element.enclosingElement.name,
	conflict.method.element.enclosingElement.name
	],
	);
	} else {
	var candidatesStr = conflict.candidates.map((candidate) {
	var className = candidate.element.enclosingElement.name;
	return '$className.$name (${candidate.displayName})';
	}).join(', ');

	_reporter.reportErrorForNode(
	CompileTimeErrorCode.INCONSISTENT_INHERITANCE,
	node,
	[name, candidatesStr],
	);
	}
	}

	void _verifyClass(SimpleIdentifier classNameNode,
	{List<ClassMember> members: const [], WithClause withClause}) {
	ClassElementImpl element = classNameNode.staticElement;
	LibraryElement library = element.library;
	InterfaceTypeImpl type = element.type;

	var allSuperinterfaces = <InterfaceType>[];

	// Add all superinterfaces of the direct supertype.
	if (type.superclass != null) {
	ClassElementImpl.collectAllSupertypes(
	allSuperinterfaces, type.superclass, null);
	}

	// Each mixin in `class C extends S with M0, M1, M2 {}` is equivalent to:
	// class S&M0 extends S { ...members of M0... }
	// class S&M1 extends S&M0 { ...members of M1... }
	// class S&M2 extends S&M1 { ...members of M2... }
	// class C extends S&M2 { ...members of C... }
	// So, we need to check members of each mixin against superinterfaces
	// of `S`, and superinterfaces of all previous mixins.
	var mixinNodes = withClause?.mixinTypes;
	var mixinTypes = type.mixins;
	for (var i = 0; i < mixinTypes.length; i++) {
	_checkDeclaredMembers(allSuperinterfaces, mixinNodes[i], mixinTypes[i]);
	ClassElementImpl.collectAllSupertypes(
	allSuperinterfaces, mixinTypes[i], null);
	}

	// Add all superinterfaces of the direct class interfaces.
	for (var interface in type.interfaces) {
	ClassElementImpl.collectAllSupertypes(
	allSuperinterfaces, interface, null);
	}

	// Check the members if the class itself, against all the previously
	// collected superinterfaces of the supertype, mixins, and interfaces.
	for (var member in members) {
	if (member is FieldDeclaration) {
	var fieldList = member.fields;
	for (var field in fieldList.variables) {
	FieldElement fieldElement = field.declaredElement;
	_checkDeclaredMember(
	allSuperinterfaces, fieldList, fieldElement.getter);
	_checkDeclaredMember(
	allSuperinterfaces, fieldList, fieldElement.setter);
	}
	} else if (member is MethodDeclaration) {
	_checkDeclaredMember(
	allSuperinterfaces, member, member.declaredElement);
	}
	}

	// Compute the interface of the class.
	var interfaceMembers = _getInterface(type, element.library);

	// Report conflicts between direct superinterfaces of the class.
	for (var conflict in interfaceMembers.conflicts) {
	_reportInconsistentInheritance(classNameNode, conflict);
	}

	// TODO(scheglov) isMixin must be also isAbstract.
	if (!element.isAbstract && !element.isMixin) {
	for (var name in interfaceMembers.map.keys) {
	var concreteElement = type.lookUpInheritedMember(name, library,
	concrete: true, thisType: true, setter: name.endsWith('='));

	// TODO(scheglov) handle here instead of ErrorVerifier?
	if (concreteElement == null) {
	continue;
	}
	// TODO(scheglov) Why InterfaceType even returns statics?
	if (concreteElement.isStatic) {
	continue;
	}

	var concreteType = concreteElement.type;
	var interfaceType = interfaceMembers.map[name];

	// The case when members have different kinds is reported in verifier.
	if (concreteType.element.kind != interfaceType.element.kind) {
	continue;
	}

	// If a class declaration is not abstract, and the interface has a
	// member declaration named `m`, then:
	// 1. if the class contains a non-overridden member whose signature is
	// not a valid override of the interface member signature for `m`,
	// then it's a compile-time error.
	// 2. if the class contains no member named `m`, and the class member
	// for `noSuchMethod` is the one declared in `Object`, then it's a
	// compile-time error. TODO(scheglov) implement this
	if (!_typeSystem.isOverrideSubtypeOf(concreteType, interfaceType)) {
	_reporter.reportErrorForNode(
	CompileTimeErrorCode.INVALID_OVERRIDE,
	classNameNode,
	[
	name,
	concreteElement.enclosingElement.name,
	concreteType.displayName,
	interfaceType.element.enclosingElement.name,
	interfaceType.displayName
	],
	);
	}
	}
	}
	}
	}

	/// Description of a failure to find a valid override from superinterfaces.
	class _Conflict {
	/// The name of an instance member for which we failed to find a valid
	/// override.
	final String name;

	/// The list of candidates for a valid override for a member [name]. It has
	/// at least two items, because otherwise the only candidate is always valid.
	final List<FunctionType> candidates;

	final FunctionType getter;
	final FunctionType method;

	_Conflict(this.name, this.candidates, [this.getter, this.method]);
	}

	/// The instance interface of an [InterfaceType].
	class _Interface {
	final Map<String, FunctionType> map;
	final List<_Conflict> conflicts;

	_Interface(this.map, this.conflicts);
	}