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