private bool VisitGenericTypeName(GenericTypeName genericTypeName)
{
var foundType = TypeCache.Lookup(genericTypeName, _typeResolutionState);
if (foundType != null)
{
((ISupportsTypeCaching)genericTypeName).CachedType = foundType;
return(true);
}
bool resolved = true;
resolved &= DispatchTypeName(genericTypeName.TypeName, genericTypeName.GenericArguments.Count, isAttribute: false);
foreach (var typeArg in genericTypeName.GenericArguments)
{
resolved &= DispatchTypeName(typeArg, genericArgumentCount: 0, isAttribute: false);
}
if (resolved)
{
var resolvedType = genericTypeName.GetReflectionType();
TypeCache.Add(genericTypeName, _typeResolutionState, resolvedType);
}
return(resolved);
}
private ITypeName GenericTypeArgumentsRule(Token genericTypeName, Token firstToken, bool unBracketedGenericArg)
{
Token token;
Token token1;
RuntimeHelpers.EnsureSufficientExecutionStack();
List<ITypeName> typeNames = new List<ITypeName>();
ITypeName singleGenericArgument = this.GetSingleGenericArgument(firstToken);
typeNames.Add(singleGenericArgument);
while (true)
{
this.V3SkipNewlines();
token = this.NextToken();
if (token.Kind != TokenKind.Comma)
{
break;
}
this.V3SkipNewlines();
token1 = this.PeekToken();
if (token1.Kind == TokenKind.Identifier || token1.Kind == TokenKind.LBracket)
{
this.SkipToken();
singleGenericArgument = this.GetSingleGenericArgument(token1);
}
else
{
this.ReportIncompleteInput(Parser.After(token), ParserStrings.MissingTypename, new object[0]);
singleGenericArgument = new TypeName(token.Extent, ":ErrorTypeName:");
}
typeNames.Add(singleGenericArgument);
}
if (token.Kind != TokenKind.RBracket)
{
this.UngetToken(token);
this.ReportIncompleteInput(Parser.Before(token), ParserStrings.EndSquareBracketExpectedAtEndOfAttribute, new object[0]);
token = null;
}
TypeName typeName = new TypeName(genericTypeName.Extent, genericTypeName.Text);
object[] objArray = new object[3];
objArray[0] = token;
objArray[1] = typeNames.LastOrDefault<ITypeName>();
objArray[2] = firstToken;
GenericTypeName genericTypeName1 = new GenericTypeName(Parser.ExtentOf(genericTypeName.Extent, Parser.ExtentFromFirstOf(objArray)), typeName, typeNames);
token1 = this.PeekToken();
if (token1.Kind != TokenKind.LBracket)
{
if (token1.Kind == TokenKind.Comma && !unBracketedGenericArg)
{
this.SkipToken();
string assemblyNameSpec = this._tokenizer.GetAssemblyNameSpec();
if (!string.IsNullOrEmpty(assemblyNameSpec))
{
typeName.AssemblyName = assemblyNameSpec;
}
else
{
this.ReportError(Parser.After(token1), ParserStrings.MissingAssemblyNameSpecification, new object[0]);
}
}
return genericTypeName1;
}
else
{
this.SkipToken();
return this.CompleteArrayTypeName(genericTypeName1, typeName, this.NextToken());
}
}
private bool VisitGenericTypeName(GenericTypeName genericTypeName)
{
var foundType = TypeCache.Lookup(genericTypeName, _typeResolutionState);
if (foundType != null)
{
((ISupportsTypeCaching)genericTypeName).CachedType = foundType;
return true;
}
bool resolved = true;
resolved &= DispatchTypeName(genericTypeName.TypeName, genericTypeName.GenericArguments.Count, isAttribute: false);
foreach (var typeArg in genericTypeName.GenericArguments)
{
resolved &= DispatchTypeName(typeArg, genericArgumentCount: 0, isAttribute: false);
}
if (resolved)
{
var resolvedType = genericTypeName.GetReflectionType();
TypeCache.Add(genericTypeName, _typeResolutionState, resolvedType);
}
return resolved;
}
private ITypeName GenericTypeArgumentsRule(Token genericTypeName, Token firstToken, bool unBracketedGenericArg)
{
Diagnostics.Assert(firstToken.Kind == TokenKind.Identifier || firstToken.Kind == TokenKind.LBracket, "unexpected first token");
RuntimeHelpers.EnsureSufficientExecutionStack();
var genericArguments = new List<ITypeName>();
ITypeName typeName = GetSingleGenericArgument(firstToken);
genericArguments.Add(typeName);
Token commaOrRBracketToken;
Token token;
while (true)
{
V3SkipNewlines();
commaOrRBracketToken = NextToken();
if (commaOrRBracketToken.Kind != TokenKind.Comma)
{
break;
}
V3SkipNewlines();
token = PeekToken();
if (token.Kind == TokenKind.Identifier || token.Kind == TokenKind.LBracket)
{
SkipToken();
typeName = GetSingleGenericArgument(token);
}
else
{
ReportIncompleteInput(After(commaOrRBracketToken), () => ParserStrings.MissingTypename);
typeName = new TypeName(commaOrRBracketToken.Extent, ":ErrorTypeName:");
}
genericArguments.Add(typeName);
}
if (commaOrRBracketToken.Kind != TokenKind.RBracket)
{
// ErrorRecovery: pretend we had the closing bracket and just continue on.
UngetToken(commaOrRBracketToken);
ReportIncompleteInput(Before(commaOrRBracketToken),
() => ParserStrings.EndSquareBracketExpectedAtEndOfAttribute);
commaOrRBracketToken = null;
}
var openGenericType = new TypeName(genericTypeName.Extent, genericTypeName.Text);
var result = new GenericTypeName(ExtentOf(genericTypeName.Extent, ExtentFromFirstOf(commaOrRBracketToken, genericArguments.LastOrDefault(), firstToken)),
openGenericType, genericArguments);
token = PeekToken();
if (token.Kind == TokenKind.LBracket)
{
SkipToken();
return CompleteArrayTypeName(result, openGenericType, NextToken());
}
if (token.Kind == TokenKind.Comma && !unBracketedGenericArg)
{
SkipToken();
string assemblyNameSpec = _tokenizer.GetAssemblyNameSpec();
if (string.IsNullOrEmpty(assemblyNameSpec))
{
ReportError(After(token), () => ParserStrings.MissingAssemblyNameSpecification);
}
else
{
openGenericType.AssemblyName = assemblyNameSpec;
}
}
return result;
}
