import ceylon.language { AnnotationType = Annotation }
​import ceylon.language.meta.model {
    ClassOrInterface,
    Member,
    AppliedType = Type,
    IncompatibleTypeException,
    TypeApplicationException​
}
​
"""A class or interface declaration.
   
   <a name="toplevel-sample">a>
   ### Usage sample for toplevel classes​
   
   Because some classes have type parameters, getting a model requires applying type arguments to the​
   class declaration with [[apply]] in order to be able to instantiate that class. For example, here is how you would​
   obtain a class or interface model that you can instantiate from a toplevel class declaration:
   
       class Foo<T>() {
           string => "Hello, our T is: ``typeLiteral<T>()``";
       }
       
       void test(){
           // We need to apply the Integer closed type to the Foo declaration in order to get the Foo<Integer> closed type​
           ClassOrInterface<Foo<Integer>> classOrInterfaceModel = `class Foo`.apply<Foo<Integer>>(`Integer`);
           assert(is Class<Foo<Integer>,[]> classOrInterfaceModel);
           // This will print: Hello, our T is: ceylon.language::Integer​
           print(classOrInterfaceModel());
       }
   
   Note that there are more specialised versions of [[apply]] in [[ClassDeclaration.classApply]] and 
   [[InterfaceDeclaration.interfaceApply]].
​
   <a name="member-sample">a>
   ### Usage sample for member classes​
	
   For member classes or interfaces it is a bit longer, because member types need to be applied not only their type arguments but also​
   the containing type, so you should use [[memberApply]] and start by giving the containing closed type:
   
       class Outer(){
           shared class Inner(){
               string => "Hello";
           }
       }
	
       void test(){
           // apply the containing closed type `Outer` to the member class declaration `Outer.Inner`​
           value memberClassModel = `class Outer.Inner`.memberApply<Outer,Outer.Inner>(`Outer`);
           assert(is MemberClass<Outer,Outer.Inner,[]> memberClassModel);
           // We now have a MemberClass, which needs to be applied to a containing instance in order to become an​
           // invokable class model:​
           Class<Outer.Inner,[]> boundMemberClassModel = memberClassModel(Outer());
           // This will print: Hello​
           print(boundMemberClassModel());
       }
   
   Note that there are more specialised versions of [[memberApply]] in [[ClassDeclaration.memberClassApply]] and 
   [[InterfaceDeclaration.memberInterfaceApply]].
   """
​shared sealed interface ClassOrInterfaceDeclaration 
        of ClassDeclaration | InterfaceDeclaration 
        satisfies NestableDeclaration & GenericDeclaration {
    
    "This type's extended type, unless this is the class for 
     [[Anything|ceylon.language::Anything]], whichis the root 
     of the type hierarchy and thus does not have any extended type."​
    shared formal OpenClassType? extendedType;
    
    "The list of types satisfied by this type."​
    shared formal OpenInterfaceType[] satisfiedTypes;
    
    "If this type has an `of` clause, this is the list of case types for the current type."​
    shared formal OpenType[] caseTypes;
    
    "True if this type is an alias type, in which case the [[extendedType]] will 
     contain the substituted type."​
    shared formal Boolean isAlias;
    
    // FIXME: should Kind default to NestableDeclaration?​
    "Returns the list of shared member declarations that satisfy the 
     given `Kind` type argument. 
     This includes inherited declarations but not unshared declarations."​
    shared formal Kind[] memberDeclarations<Kind>() 
        given Kind satisfies NestableDeclaration;
​
    "Returns the list of member declarations directly declared on this class or interface, 
     which satisfy the given `Kind` type argument. 
     This includes unshared declarations but not inherited declarations."​
    shared formal Kind[] declaredMemberDeclarations<Kind>() 
        given Kind satisfies NestableDeclaration;
​
    "Returns the list of shared member declarations that satisfy the given `Kind` type argument and
     that are annotated with the given `Annotation` type argument. This includes inherited
     declarations but not unshared declarations."​
    shared formal Kind[] annotatedMemberDeclarations<Kind, Annotation>() 
        given Kind satisfies NestableDeclaration​
        given Annotation satisfies AnnotationType;
    
    "Returns the list of member declarations directly declared on this class or interface, which satisfy the given 
     `Kind` type argument and that are annotated with the given `Annotation` type argument.
     This includes unshared declarations but not inherited declarations."​
    shared formal Kind[] annotatedDeclaredMemberDeclarations<Kind, Annotation>() 
        given Kind satisfies NestableDeclaration​
        given Annotation satisfies AnnotationType;
    
    "Looks up a shared member declaration by name, 
     provided it satisfies the given `Kind` type argument. 
     Returns `null` if no such member matches. 
     This includes inherited declarations but not unshared declarations"​
    shared formal Kind? getMemberDeclaration<Kind>(String name) 
        given Kind satisfies NestableDeclaration;
​
    "Looks up a member declaration directly declared on this class or interface, by name, 
     provided it satisfies the given `Kind` type argument. 
     Returns `null` if no such member matches. 
     This includes unshared declarations but not inherited declarations."​
    shared formal Kind? getDeclaredMemberDeclaration<Kind>(String name) 
        given Kind satisfies NestableDeclaration;
    
    "Applies the given closed type arguments to this toplevel class or interface declaration in order to obtain a class or interface model. 
     See [this code sample](#toplevel-sample) for an example on how to use this."​
    throws(`class IncompatibleTypeException`, 
        "If the specified `Type` type argument is not compatible with the actual result.")
    throws(`class TypeApplicationException`, 
            "If the specified closed type argument values are not compatible 
             with the actual result's type parameters.")
    shared formal ClassOrInterface<Type> apply<Type=Anything>(AppliedType<>* typeArguments);
    
    "Applies the given closed container type and type arguments to this member class or interface declaration in order to obtain a 
     member class or interface model. See [this code sample](#member-sample) for an example on how to use this."​
    throws(`class IncompatibleTypeException`, 
        "If the specified `Container` or `Type` type arguments are not 
         compatible with the actual result.")
    throws(`class TypeApplicationException`, 
            "If the specified closed container type or type argument values 
             are not compatible with the actual result's container type or 
             type parameters.")
    shared formal Member<Container, ClassOrInterface<Type>> & ClassOrInterface<Type> memberApply​
            <Container=Nothing, Type=Anything>
            (AppliedType<Object> containerType, AppliedType<>* typeArguments);
​
}
​