public static TypeReferenceCollection FromArray(params Boo.Lang.Compiler.Ast.TypeReference[] items)
{
var collection = new TypeReferenceCollection();
collection.AddRange(items);
return(collection);
}
public GenericConstructionChecker(TypeSystemServices tss, Node constructionNode, TypeReferenceCollection argumentNodes, CompilerErrorCollection errorCollection)
{
_tss = tss;
_constructionNode = constructionNode;
_argumentNodes = argumentNodes;
_errors = errorCollection;
}
void ConvertTypeReferences(List <TypeReference> input, B.TypeReferenceCollection output)
{
foreach (TypeReference t in input)
{
B.TypeReference r = ConvertTypeReference(t);
if (r != null)
{
output.Add(r);
}
}
}
protected void type_reference_list(
TypeReferenceCollection container
) //throws RecognitionException, TokenStreamException
{
TypeReference tr = null;
try { // for error handling
tr=type_reference();
if (0==inputState.guessing)
{
container.Add(tr);
}
{ // ( ... )*
for (;;)
{
if ((LA(1)==COMMA))
{
match(COMMA);
tr=type_reference();
if (0==inputState.guessing)
{
container.Add(tr);
}
}
else
{
goto _loop246_breakloop;
}
}
_loop246_breakloop: ;
} // ( ... )*
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "type_reference_list");
recover(ex,tokenSet_41_);
}
else
{
throw ex;
}
}
}
protected void base_types(
TypeReferenceCollection container
) //throws RecognitionException, TokenStreamException
{
TypeReference tr = null;
try { // for error handling
match(LPAREN);
{
switch ( LA(1) )
{
case CALLABLE:
case CHAR:
case THEN:
case LPAREN:
case ID:
case SPLICE_BEGIN:
{
tr=type_reference();
if (0==inputState.guessing)
{
container.Add(tr);
}
{ // ( ... )*
for (;;)
{
if ((LA(1)==COMMA))
{
match(COMMA);
tr=type_reference();
if (0==inputState.guessing)
{
container.Add(tr);
}
}
else
{
goto _loop94_breakloop;
}
}
_loop94_breakloop: ;
} // ( ... )*
break;
}
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RPAREN);
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "base_types");
recover(ex,tokenSet_54_);
}
else
{
throw ex;
}
}
}
public static IReturnType CreateReturnType(AST.TypeReference reference, IClass callingClass,
IMethodOrProperty callingMember, int caretLine, int caretColumn,
IProjectContent projectContent)
{
System.Diagnostics.Debug.Assert(projectContent != null);
if (reference == null)
{
return(GetDefaultReturnType(projectContent));
}
if (reference is AST.ArrayTypeReference)
{
AST.ArrayTypeReference arr = (AST.ArrayTypeReference)reference;
return(new ArrayReturnType(projectContent,
CreateReturnType(arr.ElementType, callingClass, callingMember,
caretLine, caretColumn, projectContent),
(arr.Rank != null) ? (int)arr.Rank.Value : 1));
}
else if (reference is AST.SimpleTypeReference)
{
string name = ((AST.SimpleTypeReference)reference).Name;
IReturnType rt;
int typeParameterCount = (reference is AST.GenericTypeReference) ? ((AST.GenericTypeReference)reference).GenericArguments.Count : 0;
if (name == "duck")
{
rt = new BooResolver.DuckClass(new DefaultCompilationUnit(projectContent)).DefaultReturnType;
}
else if (BooAmbience.ReverseTypeConversionTable.ContainsKey(name))
{
rt = new GetClassReturnType(projectContent, BooAmbience.ReverseTypeConversionTable[name], typeParameterCount);
}
else if (callingClass == null)
{
rt = new GetClassReturnType(projectContent, name, typeParameterCount);
}
else
{
rt = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn,
name, typeParameterCount);
}
if (typeParameterCount > 0)
{
AST.TypeReferenceCollection arguments = ((AST.GenericTypeReference)reference).GenericArguments;
// GenericTypeReference derives from SimpleTypeReference
IReturnType[] typeArguments = new IReturnType[arguments.Count];
for (int i = 0; i < typeArguments.Length; i++)
{
typeArguments[i] = CreateReturnType(arguments[i], callingClass, callingMember, caretLine, caretColumn,
projectContent);
}
rt = new ConstructedReturnType(rt, typeArguments);
}
return(rt);
}
else if (reference is AST.CallableTypeReference)
{
AST.CallableTypeReference ctr = (AST.CallableTypeReference)reference;
AnonymousMethodReturnType amrt = new AnonymousMethodReturnType(new DefaultCompilationUnit(projectContent));
if (ctr.ReturnType != null)
{
amrt.MethodReturnType = CreateReturnType(ctr.ReturnType, callingClass, callingMember, caretLine, caretColumn, projectContent);
}
amrt.MethodParameters = new List <IParameter>();
AddParameters(ctr.Parameters, amrt.MethodParameters, callingMember, callingClass ?? new DefaultClass(new DefaultCompilationUnit(projectContent), "__Dummy"));
return(amrt);
}
else
{
throw new NotSupportedException("unknown reference type: " + reference.ToString());
}
}
/// <summary>
/// Constructs generic entities out of an ambiguous definition.
/// </summary>
private IEntity ConstructAmbiguousEntity(Ambiguous ambiguousDefinition, Node constructionNode, TypeReferenceCollection argumentNodes)
{
GenericConstructionChecker checker = new GenericConstructionChecker(
TypeSystemServices,
constructionNode,
argumentNodes,
new CompilerErrorCollection());
List<IEntity> matches = new List<IEntity>(ambiguousDefinition.Entities);
// Filter matches by genericness, generity and constraints
Predicate<IEntity>[] filters = new Predicate<IEntity>[] {
checker.NotGenericDefinition,
checker.IncorrectGenerity,
checker.ViolatesParameterConstraints };
foreach (Predicate<IEntity> filter in filters)
{
checker.Errors.Clear();
matches.RemoveAll(filter);
// If no matches pass the filter, record the first error only
// (providing all the distinct errors that occured would be superfluous)
if (matches.Count == 0)
{
Errors.Add(checker.Errors[0]);
return TypeSystemServices.ErrorEntity;
}
// If only one match passes the filter, continue construction normally
if (matches.Count == 1)
{
return ConstructEntity(matches[0], constructionNode, argumentNodes);
}
}
// Several matches have passed the filter -
// construct all of them and return another Ambiguous entity
IEntity[] constructed = Array.ConvertAll<IEntity, IEntity>(
matches.ToArray(),
delegate(IEntity def) { return ConstructEntity(def, constructionNode, argumentNodes); });
return new Ambiguous(constructed);
}
/// <summary>
/// Checks whether a given set of arguments can be used to construct a generic type or method from a specified definition.
/// </summary>
public bool CheckGenericConstruction(IEntity definition, Node node, TypeReferenceCollection arguments, CompilerErrorCollection errors)
{
// Ensure definition is a valid entity
if (definition == null || TypeSystemServices.IsError(definition))
{
return false;
}
// Ensure definition really is a generic definition
GenericConstructionChecker checker = new GenericConstructionChecker(
TypeSystemServices, node, arguments, Errors);
return !(
checker.NotGenericDefinition(definition) ||
checker.IncorrectGenerity(definition) ||
checker.ViolatesParameterConstraints(definition));
}
/// <summary>
/// Constructs an entity from a generic definition and arguments, after ensuring the construction is valid.
/// </summary>
/// <param name="definition">The generic definition entity.</param>
/// <param name="node">The node in which construction occurs.</param>
/// <param name="argumentNodes">The nodes of the arguments supplied for generic construction.</param>
/// <returns>The constructed entity.</returns>
public IEntity ConstructEntity(IEntity definition, Node constructionNode, TypeReferenceCollection argumentNodes)
{
// Ambiguous generic constructions are handled separately
if (definition.EntityType == EntityType.Ambiguous)
{
return ConstructAmbiguousEntity((Ambiguous)definition, constructionNode, argumentNodes);
}
// Check that the construction is valid
if (!CheckGenericConstruction(definition, constructionNode, argumentNodes, Errors))
{
return TypeSystemServices.ErrorEntity;
}
// Construct a type or a method according to the definition
IType[] arguments = Array.ConvertAll<TypeReference, IType>(
argumentNodes.ToArray(),
delegate(TypeReference tr) { return (IType)tr.Entity; });
if (IsGenericType(definition))
{
return ((IType)definition).GenericInfo.ConstructType(arguments);
}
if (IsGenericMethod(definition))
{
return ((IMethod)definition).GenericInfo.ConstructMethod(arguments);
}
// Should never be reached - if definition is neither a generic type nor a generic method,
// CheckGenericConstruction would've indicated this
return TypeSystemServices.ErrorEntity;
}
void WriteGenericArguments(TypeReferenceCollection arguments)
{
Write("[of ");
WriteCommaSeparatedList(arguments);
Write("]");
}
public Boo.Lang.Compiler.Ast.TypeReferenceCollection PopRange(int begin)
{
Boo.Lang.Compiler.Ast.TypeReferenceCollection range = new Boo.Lang.Compiler.Ast.TypeReferenceCollection(_parent);
range.InnerList.Extend(InternalPopRange(begin));
return(range);
}
public void type_reference_list(TypeReferenceCollection typeReferences)
{
try
{
TypeReference reference = this.type_reference();
if (base.inputState.guessing == 0)
{
typeReferences.Add(reference);
}
while (this.LA(1) == 0x43)
{
this.match(0x43);
reference = this.type_reference();
if (base.inputState.guessing == 0)
{
typeReferences.Add(reference);
}
}
}
catch (RecognitionException exception)
{
if (base.inputState.guessing != 0)
{
throw;
}
this.reportError(exception);
this.recover(exception, tokenSet_36_);
}
}
private void ResolveTypeReferenceCollection(TypeReferenceCollection collection)
{
foreach (TypeReference tr in collection)
{
ResolveTypeReference(tr);
}
}
private IType[] GetTypes(TypeReferenceCollection typeReferences)
{
return Array.ConvertAll<TypeReference, IType>(
typeReferences.ToArray(),
TypeSystemServices.GetType);
}
