protected override void ProcessRecord()
{
Type type = new TypeName(this.TypeName).GetReflectionType();
var result = Activator.CreateInstance(type, this.ArgumentList);
WriteObject(result);
}
protected override void ProcessRecord()
{
Type type = new TypeName(this.TypeName).GetReflectionType();
var result = PSObject.AsPSObject(Activator.CreateInstance(type, this.ArgumentList));
if (Property != null)
{
AddProperties(result);
}
WriteObject(result);
}
private bool VisitTypeName(TypeName typeName, int genericArgumentCount, bool isAttribute)
{
var classDefn = _symbolTable.LookupType(typeName);
if (classDefn != null && classDefn.IsAmbiguous())
{
_parser.ReportError(typeName.Extent, () => ParserStrings.AmbiguousTypeReference,
typeName.Name,
GetModuleQualifiedName(classDefn.ExternalNamespaces[0], typeName.Name),
GetModuleQualifiedName(classDefn.ExternalNamespaces[1], typeName.Name));
}
else if (classDefn != null && genericArgumentCount == 0)
{
typeName.SetTypeDefinition(classDefn.Type);
}
else
{
Exception e;
TypeResolutionState trs = genericArgumentCount > 0 || isAttribute
? new TypeResolutionState(_typeResolutionState, genericArgumentCount, isAttribute)
: _typeResolutionState;
var type = TypeResolver.ResolveTypeNameWithContext(typeName, out e, null, trs);
if (type == null)
{
if (_symbolTable.GetCurrentTypeDefinitionAst() != null)
{
// [ordered] is an attribute, but it's looks like a type constraint.
if (!typeName.FullName.Equals(LanguagePrimitives.OrderedAttribute, StringComparison.OrdinalIgnoreCase))
{
_parser.ReportError(typeName.Extent,
isAttribute
? (Expression<Func<string>>)(() => ParserStrings.CustomAttributeTypeNotFound)
: () => ParserStrings.TypeNotFound, typeName.Name);
}
}
}
else
{
((ISupportsTypeCaching)typeName).CachedType = type;
return true;
}
}
return false;
}
public TypeLookupResult LookupType(TypeName typeName)
{
TypeLookupResult result = null;
for (int i = _scopes.Count - 1; i >= 0; i--)
{
result = _scopes[i].LookupType(typeName);
if (result != null)
break;
}
return result;
}
internal TypeLookupResult LookupType(TypeName typeName)
{
if (typeName.AssemblyName != null)
{
return null;
}
TypeLookupResult typeLookupResult;
_typeTable.TryGetValue(typeName.Name, out typeLookupResult);
return typeLookupResult;
}
private ITypeName CompleteArrayTypeName(ITypeName elementType, TypeName typeForAssemblyQualification, Token firstTokenAfterLBracket)
{
Token token;
Token token1;
while (true)
{
TokenKind kind = firstTokenAfterLBracket.Kind;
if (kind == TokenKind.EndOfInput)
{
this.UngetToken(firstTokenAfterLBracket);
this.ReportError(Parser.Before(firstTokenAfterLBracket), ParserStrings.EndSquareBracketExpectedAtEndOfAttribute, new object[0]);
}
else
{
if (kind == TokenKind.RBracket)
{
elementType = new ArrayTypeName(Parser.ExtentOf(elementType.Extent, firstTokenAfterLBracket.Extent), elementType, 1);
}
else
{
if (kind != TokenKind.Comma)
{
object[] text = new object[1];
text[0] = firstTokenAfterLBracket.Text;
this.ReportError(firstTokenAfterLBracket.Extent, ParserStrings.UnexpectedToken, text);
TokenKind[] tokenKindArray = new TokenKind[1];
tokenKindArray[0] = TokenKind.RBracket;
this.SyncOnError(tokenKindArray);
}
else
{
int num = 1;
token = firstTokenAfterLBracket;
do
{
token1 = token;
num++;
token = this.NextToken();
}
while (token.Kind == TokenKind.Comma);
if (token.Kind != TokenKind.RBracket)
{
this.UngetToken(token);
this.ReportError(Parser.After(token1), ParserStrings.EndSquareBracketExpectedAtEndOfAttribute, new object[0]);
}
elementType = new ArrayTypeName(Parser.ExtentOf(elementType.Extent, token.Extent), elementType, num);
}
}
}
token = this.PeekToken();
if (token.Kind != TokenKind.Comma)
{
if (token.Kind != TokenKind.LBracket)
{
break;
}
this.SkipToken();
firstTokenAfterLBracket = this.NextToken();
}
else
{
this.SkipToken();
string assemblyNameSpec = this._tokenizer.GetAssemblyNameSpec();
if (!string.IsNullOrEmpty(assemblyNameSpec))
{
typeForAssemblyQualification.AssemblyName = assemblyNameSpec;
break;
}
else
{
this.ReportError(Parser.After(token), ParserStrings.MissingAssemblyNameSpecification, new object[0]);
break;
}
}
}
return elementType;
}
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 ITypeName FinishTypeNameRule(Token typeName, bool unBracketedGenericArg = false)
{
TypeName typeName1;
Token token = this.PeekToken();
if (token.Kind != TokenKind.LBracket)
{
if (token.Kind != TokenKind.Comma || unBracketedGenericArg)
{
return new TypeName(typeName.Extent, typeName.Text);
}
else
{
this.SkipToken();
string assemblyNameSpec = this._tokenizer.GetAssemblyNameSpec();
if (!string.IsNullOrWhiteSpace(assemblyNameSpec))
{
return new TypeName(Parser.ExtentOf(typeName.Extent, this._tokenizer.CurrentExtent()), typeName.Text, assemblyNameSpec);
}
else
{
this.ReportError(Parser.After(token), ParserStrings.MissingAssemblyNameSpecification, new object[0]);
return new TypeName(typeName.Extent, typeName.Text);
}
}
}
else
{
Token token1 = token;
this.SkipToken();
this.V3SkipNewlines();
token = this.NextToken();
TokenKind kind = token.Kind;
if (kind != TokenKind.Identifier)
{
if (kind == TokenKind.LBracket)
{
return this.GenericTypeArgumentsRule(typeName, token, unBracketedGenericArg);
}
else if (kind == TokenKind.RBracket)
{
typeName1 = new TypeName(typeName.Extent, typeName.Text);
return this.CompleteArrayTypeName(typeName1, typeName1, token);
}
if (kind != TokenKind.Comma)
{
if (token.Kind == TokenKind.EndOfInput)
{
this.UngetToken(token);
this.ReportIncompleteInput(Parser.After(token1), ParserStrings.MissingTypename, new object[0]);
}
else
{
object[] text = new object[1];
text[0] = token.Text;
this.ReportError(token.Extent, ParserStrings.UnexpectedToken, text);
TokenKind[] tokenKindArray = new TokenKind[1];
tokenKindArray[0] = TokenKind.RBracket;
this.SyncOnError(tokenKindArray);
}
return new TypeName(typeName.Extent, typeName.Text);
}
typeName1 = new TypeName(typeName.Extent, typeName.Text);
return this.CompleteArrayTypeName(typeName1, typeName1, token);
}
return this.GenericTypeArgumentsRule(typeName, token, unBracketedGenericArg);
}
}
private ITypeName CompleteArrayTypeName(ITypeName elementType, TypeName typeForAssemblyQualification, Token firstTokenAfterLBracket)
{
while (true)
{
Token token;
switch (firstTokenAfterLBracket.Kind)
{
case TokenKind.Comma:
int dim = 1;
token = firstTokenAfterLBracket;
Token lastComma;
do
{
lastComma = token;
dim += 1;
token = NextToken();
} while (token.Kind == TokenKind.Comma);
if (token.Kind != TokenKind.RBracket)
{
// ErrorRecovery: just pretend we saw a ']'.
UngetToken(token);
ReportError(After(lastComma), () => ParserStrings.EndSquareBracketExpectedAtEndOfAttribute);
}
elementType = new ArrayTypeName(ExtentOf(elementType.Extent, token.Extent), elementType, dim);
break;
case TokenKind.RBracket:
elementType = new ArrayTypeName(ExtentOf(elementType.Extent, firstTokenAfterLBracket.Extent), elementType, 1);
break;
case TokenKind.EndOfInput:
UngetToken(firstTokenAfterLBracket);
ReportError(Before(firstTokenAfterLBracket), () => ParserStrings.EndSquareBracketExpectedAtEndOfAttribute);
break;
default:
// ErrorRecovery: sync to ']', and return null to avoid cascading errors.
ReportError(firstTokenAfterLBracket.Extent, () => ParserStrings.UnexpectedToken, firstTokenAfterLBracket.Text);
SyncOnError(true, TokenKind.RBracket);
break;
}
token = PeekToken();
if (token.Kind == TokenKind.Comma)
{
SkipToken();
var assemblyName = _tokenizer.GetAssemblyNameSpec();
if (string.IsNullOrEmpty(assemblyName))
{
ReportError(After(token), () => ParserStrings.MissingAssemblyNameSpecification);
}
else
{
typeForAssemblyQualification.AssemblyName = assemblyName;
}
break;
}
if (token.Kind != TokenKind.LBracket)
{
break;
}
// Jagged array, skip the '[' and keep parsing.
SkipToken();
firstTokenAfterLBracket = NextToken();
}
return elementType;
}
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;
}
private ITypeName FinishTypeNameRule(Token typeName, bool unBracketedGenericArg = false, bool allowAssemblyQualifiedNames = true)
{
Diagnostics.Assert(typeName.Kind == TokenKind.Identifier, "Caller must verify the argument.");
Token token = PeekToken();
if (token.Kind == TokenKind.LBracket)
{
var lbracket = token;
// Array or generic
SkipToken();
V3SkipNewlines();
token = NextToken();
switch (token.Kind)
{
case TokenKind.RBracket:
case TokenKind.Comma:
var elementType = new TypeName(typeName.Extent, typeName.Text);
return CompleteArrayTypeName(elementType, elementType, token);
case TokenKind.LBracket:
case TokenKind.Identifier:
return GenericTypeArgumentsRule(typeName, token, unBracketedGenericArg);
default:
// ErrorRecovery: sync to ']', and return non-null to avoid cascading errors.
if (token.Kind != TokenKind.EndOfInput)
{
ReportError(token.Extent, () => ParserStrings.UnexpectedToken, token.Text);
SyncOnError(true, TokenKind.RBracket);
}
else
{
UngetToken(token);
ReportIncompleteInput(After(lbracket), () => ParserStrings.MissingTypename);
}
return new TypeName(typeName.Extent, typeName.Text);
}
}
if (token.Kind == TokenKind.Comma && allowAssemblyQualifiedNames && !unBracketedGenericArg)
{
SkipToken();
string assemblyNameSpec = _tokenizer.GetAssemblyNameSpec();
if (string.IsNullOrWhiteSpace(assemblyNameSpec))
{
ReportError(After(token), () => ParserStrings.MissingAssemblyNameSpecification);
return new TypeName(typeName.Extent, typeName.Text);
}
return new TypeName(ExtentOf(typeName.Extent, _tokenizer.CurrentExtent()), typeName.Text, assemblyNameSpec);
}
return new TypeName(typeName.Extent, typeName.Text);
}
