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; }