public object VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
// Type expressions are not safe as they allow fingerprinting by providing
// a set of types, you can inspect the types in the AppDomain implying which assemblies are in use
// and their version
throw PSTraceSource.NewArgumentException("ast");
}
public object VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
// Type expressions are not safe as they allow fingerprinting by providing
// a set of types, you can inspect the types in the AppDomain implying which assemblies are in use
// and their version
return(false);
}
public override AstVisitAction VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
if (typeExpressionAst.Parent is BinaryExpressionAst ||
typeExpressionAst.Parent is CommandExpressionAst ||
typeExpressionAst.Parent is AssignmentStatementAst)
{
HelpEntity help = null;
var description = string.Empty;
if (typeExpressionAst.TypeName.IsArray)
{
description = $"Array of '{typeExpressionAst.TypeName.Name}'";
help = new HelpEntity()
{
DocumentationLink = "https://docs.microsoft.com/en-us/powershell/scripting/lang-spec/chapter-04"
};
}
else if (typeExpressionAst.TypeName.IsGeneric)
{
description = $"Generic type";
help = new HelpEntity()
{
DocumentationLink = "https://docs.microsoft.com/en-us/powershell/scripting/lang-spec/chapter-04#44-generic-types"
};
}
explanations.Add(new Explanation()
{
Description = description,
CommandName = "Type expression",
HelpResult = help
}.AddDefaults(typeExpressionAst, explanations));
}
return(base.VisitTypeExpression(typeExpressionAst));
}
public static TypeExpressionAst Update(
this TypeExpressionAst ast,
string typeName)
{
return(new TypeExpressionAst(
ast.Extent,
new TypeName(ast.TypeName.Extent, typeName)));
}
public override AstVisitAction VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
var name = typeExpressionAst.TypeName.Name;
_currentNode = new TypeExpression(name);
return(AstVisitAction.SkipChildren);
}
public static TypeExpressionAst Update(
this TypeExpressionAst ast,
string typeName,
IEnumerable <ITypeName> genericTypeArguments)
{
return(new TypeExpressionAst(
ast.Extent,
new GenericTypeName(
ast.TypeName.Extent,
new TypeName(ast.TypeName.Extent, typeName),
genericTypeArguments)));
}
public static TypeExpressionAst Update(
this TypeExpressionAst ast,
string typeName,
int arrayRank)
{
return(new TypeExpressionAst(
ast.Extent,
new ArrayTypeName(
ast.TypeName.Extent,
new TypeName(ast.TypeName.Extent, typeName),
arrayRank)));
}
/// <summary>
/// AnalyzeScript: check that Write-Host or Console.Write are not used.
/// </summary>
public IEnumerable <DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
{
if (ast == null)
{
throw new ArgumentNullException(Strings.NullAstErrorMessage);
}
// Finds all CommandAsts.
IEnumerable <Ast> commandAsts = ast.FindAll(testAst => testAst is CommandAst, true);
// Iterrates all CommandAsts and check the command name.
foreach (CommandAst cmdAst in commandAsts)
{
if (cmdAst.GetCommandName() != null && String.Equals(cmdAst.GetCommandName(), "write-host", StringComparison.OrdinalIgnoreCase))
{
yield return(new DiagnosticRecord(String.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingWriteHostError, System.IO.Path.GetFileName(fileName)),
cmdAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName));
}
}
// Finds all InvokeMemberExpressionAst
IEnumerable <Ast> invokeAsts = ast.FindAll(testAst => testAst is InvokeMemberExpressionAst, true);
foreach (InvokeMemberExpressionAst invokeAst in invokeAsts)
{
TypeExpressionAst typeAst = invokeAst.Expression as TypeExpressionAst;
if (typeAst == null || typeAst.TypeName == null || typeAst.TypeName.FullName == null)
{
continue;
}
if (typeAst.TypeName.FullName.EndsWith("console", StringComparison.OrdinalIgnoreCase) &&
!String.IsNullOrWhiteSpace(invokeAst.Member.Extent.Text) && invokeAst.Member.Extent.Text.StartsWith("Write", StringComparison.OrdinalIgnoreCase))
{
yield return(new DiagnosticRecord(String.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingConsoleWriteError, System.IO.Path.GetFileName(fileName), invokeAst.Member.Extent.Text),
invokeAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName));
}
}
}
public override AstVisitAction VisitCommand(CommandAst commandAst)
{
string commandName = commandAst?.GetCommandName();
if (commandName == null)
{
return(AstVisitAction.Continue);
}
if (commandName.Equals("New-Object"))
{
if (!TryGetArgument(commandAst.CommandElements, 0, "TypeName", out CommandElementAst typeNameArg))
{
return(AstVisitAction.Continue);
}
if (!(typeNameArg is StringConstantExpressionAst typeNameStringExp))
{
return(AstVisitAction.Continue);
}
// We need the PowerShell parser to turn this into something structured now
TypeExpressionAst typeNameAst = (TypeExpressionAst)Parser.ParseInput("[" + typeNameStringExp.Value + "]", out Token[] tokens, out ParseError[] errors)
public override AstVisitAction VisitInvokeMemberExpression(InvokeMemberExpressionAst imeAst)
{
if (imeAst == null)
{
return(AstVisitAction.SkipChildren);
}
TypeExpressionAst typeAst = imeAst.Expression as TypeExpressionAst;
if (typeAst == null || typeAst.TypeName == null || typeAst.TypeName.FullName == null)
{
return(AstVisitAction.SkipChildren);
}
if (typeAst.TypeName.FullName.EndsWith("console", StringComparison.OrdinalIgnoreCase) &&
!String.IsNullOrWhiteSpace(imeAst.Member.Extent.Text) && imeAst.Member.Extent.Text.StartsWith("Write", StringComparison.OrdinalIgnoreCase))
{
records.Add(new DiagnosticRecord(String.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingConsoleWriteError, System.IO.Path.GetFileName(fileName), imeAst.Member.Extent.Text),
imeAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName));
}
return(AstVisitAction.Continue);
}
public override object VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
script_.Write("[" + typeExpressionAst.TypeName + "]");
return(typeExpressionAst);
}
internal List <CompletionResult> GetResultHelper(CompletionContext completionContext, out int replacementIndex, out int replacementLength, bool isQuotedString)
{
replacementIndex = -1;
replacementLength = -1;
Token tokenAtCursor = completionContext.TokenAtCursor;
Ast lastAst = completionContext.RelatedAsts.Last <Ast>();
List <CompletionResult> list = null;
if (tokenAtCursor == null)
{
if (!isQuotedString && (((((lastAst is CommandParameterAst) || (lastAst is CommandAst)) || ((lastAst is ExpressionAst) && (lastAst.Parent is CommandAst))) || ((lastAst is ExpressionAst) && (lastAst.Parent is CommandParameterAst))) || (((lastAst is ExpressionAst) && (lastAst.Parent is ArrayLiteralAst)) && ((lastAst.Parent.Parent is CommandAst) || (lastAst.Parent.Parent is CommandParameterAst)))))
{
completionContext.WordToComplete = string.Empty;
HashtableAst hashtableAst = lastAst as HashtableAst;
if (hashtableAst != null)
{
completionContext.ReplacementIndex = replacementIndex = completionContext.CursorPosition.Offset;
completionContext.ReplacementLength = replacementLength = 0;
list = CompletionCompleters.CompleteHashtableKey(completionContext, hashtableAst);
}
else
{
list = CompletionCompleters.CompleteCommandArgument(completionContext);
replacementIndex = completionContext.ReplacementIndex;
replacementLength = completionContext.ReplacementLength;
}
}
else if (!isQuotedString)
{
bool flag = false;
if ((lastAst is ErrorExpressionAst) && (lastAst.Parent is FileRedirectionAst))
{
flag = true;
}
else if ((lastAst is ErrorStatementAst) && CompleteAgainstSwitchFile(lastAst, completionContext.TokenBeforeCursor))
{
flag = true;
}
if (flag)
{
completionContext.WordToComplete = string.Empty;
list = new List <CompletionResult>(CompletionCompleters.CompleteFilename(completionContext));
replacementIndex = completionContext.ReplacementIndex;
replacementLength = completionContext.ReplacementLength;
}
}
}
else
{
TokenKind kind;
replacementIndex = tokenAtCursor.Extent.StartScriptPosition.Offset;
replacementLength = tokenAtCursor.Extent.EndScriptPosition.Offset - replacementIndex;
completionContext.ReplacementIndex = replacementIndex;
completionContext.ReplacementLength = replacementLength;
switch (tokenAtCursor.Kind)
{
case TokenKind.ColonColon:
case TokenKind.Dot:
replacementIndex += tokenAtCursor.Text.Length;
replacementLength = 0;
list = CompletionCompleters.CompleteMember(completionContext, tokenAtCursor.Kind == TokenKind.ColonColon);
goto Label_05DC;
case TokenKind.Multiply:
case TokenKind.Identifier:
case TokenKind.Generic:
list = this.GetResultForIdentifier(completionContext, ref replacementIndex, ref replacementLength, isQuotedString);
goto Label_05DC;
case TokenKind.Minus:
if (CompleteOperator(tokenAtCursor, lastAst))
{
list = CompletionCompleters.CompleteOperator("");
}
else if (CompleteAgainstStatementFlags(completionContext.RelatedAsts[0], null, tokenAtCursor, out kind))
{
completionContext.WordToComplete = tokenAtCursor.Text;
list = CompletionCompleters.CompleteStatementFlags(kind, completionContext.WordToComplete);
}
goto Label_05DC;
case TokenKind.Redirection:
if ((lastAst is ErrorExpressionAst) && (lastAst.Parent is FileRedirectionAst))
{
completionContext.WordToComplete = string.Empty;
completionContext.ReplacementIndex = replacementIndex += tokenAtCursor.Text.Length;
completionContext.ReplacementLength = replacementLength = 0;
list = new List <CompletionResult>(CompletionCompleters.CompleteFilename(completionContext));
}
goto Label_05DC;
case TokenKind.Variable:
case TokenKind.SplattedVariable:
completionContext.WordToComplete = ((VariableToken)tokenAtCursor).VariablePath.UserPath;
list = CompletionCompleters.CompleteVariable(completionContext);
goto Label_05DC;
case TokenKind.Parameter:
if (!isQuotedString)
{
completionContext.WordToComplete = tokenAtCursor.Text;
CommandAst parent = lastAst.Parent as CommandAst;
if ((!(lastAst is StringConstantExpressionAst) || (parent == null)) || (parent.CommandElements.Count != 1))
{
if (CompleteAgainstStatementFlags(null, lastAst, null, out kind))
{
list = CompletionCompleters.CompleteStatementFlags(kind, completionContext.WordToComplete);
}
else if (CompleteOperator(tokenAtCursor, lastAst))
{
list = CompletionCompleters.CompleteOperator(completionContext.WordToComplete);
}
else if (completionContext.WordToComplete.EndsWith(":", StringComparison.Ordinal))
{
replacementIndex = tokenAtCursor.Extent.EndScriptPosition.Offset;
replacementLength = 0;
completionContext.WordToComplete = string.Empty;
list = CompletionCompleters.CompleteCommandArgument(completionContext);
}
else
{
list = CompletionCompleters.CompleteCommandParameter(completionContext);
}
}
else
{
list = CompleteFileNameAsCommand(completionContext);
}
}
goto Label_05DC;
case TokenKind.Number:
if ((lastAst is ConstantExpressionAst) && (((lastAst.Parent is CommandAst) || (lastAst.Parent is CommandParameterAst)) || ((lastAst.Parent is ArrayLiteralAst) && ((lastAst.Parent.Parent is CommandAst) || (lastAst.Parent.Parent is CommandParameterAst)))))
{
completionContext.WordToComplete = tokenAtCursor.Text;
list = CompletionCompleters.CompleteCommandArgument(completionContext);
replacementIndex = completionContext.ReplacementIndex;
replacementLength = completionContext.ReplacementLength;
}
goto Label_05DC;
case TokenKind.Comment:
if (!isQuotedString)
{
completionContext.WordToComplete = tokenAtCursor.Text;
list = CompletionCompleters.CompleteComment(completionContext);
}
goto Label_05DC;
case TokenKind.StringLiteral:
case TokenKind.StringExpandable:
list = this.GetResultForString(completionContext, ref replacementIndex, ref replacementLength, isQuotedString);
goto Label_05DC;
case TokenKind.RBracket:
if (lastAst is TypeExpressionAst)
{
TypeExpressionAst targetExpr = (TypeExpressionAst)lastAst;
List <CompletionResult> results = new List <CompletionResult>();
CompletionCompleters.CompleteMemberHelper(true, "*", targetExpr, completionContext, results);
if (results.Count > 0)
{
replacementIndex++;
replacementLength = 0;
list = (from entry in results
let completionText = TokenKind.ColonColon.Text() + entry.CompletionText
select new CompletionResult(completionText, entry.ListItemText, entry.ResultType, entry.ToolTip)).ToList <CompletionResult>();
}
}
goto Label_05DC;
case TokenKind.Comma:
if ((lastAst is ErrorExpressionAst) && ((lastAst.Parent is CommandAst) || (lastAst.Parent is CommandParameterAst)))
{
replacementIndex += replacementLength;
replacementLength = 0;
list = CompletionCompleters.CompleteCommandArgument(completionContext);
}
goto Label_05DC;
}
if ((tokenAtCursor.TokenFlags & TokenFlags.Keyword) != TokenFlags.None)
{
completionContext.WordToComplete = tokenAtCursor.Text;
list = CompleteFileNameAsCommand(completionContext);
List <CompletionResult> collection = CompletionCompleters.CompleteCommand(completionContext);
if ((collection != null) && (collection.Count > 0))
{
list.AddRange(collection);
}
}
else
{
replacementIndex = -1;
replacementLength = -1;
}
}
Label_05DC:
if ((list == null) || (list.Count == 0))
{
TypeExpressionAst ast5 = completionContext.RelatedAsts.OfType <TypeExpressionAst>().FirstOrDefault <TypeExpressionAst>();
TypeName name = null;
if (ast5 != null)
{
name = FindTypeNameToComplete(ast5.TypeName, this._cursorPosition);
}
else
{
TypeConstraintAst ast6 = completionContext.RelatedAsts.OfType <TypeConstraintAst>().FirstOrDefault <TypeConstraintAst>();
if (ast6 != null)
{
name = FindTypeNameToComplete(ast6.TypeName, this._cursorPosition);
}
}
if (name != null)
{
replacementIndex = name.Extent.StartOffset;
replacementLength = name.Extent.EndOffset - replacementIndex;
completionContext.WordToComplete = name.FullName;
list = CompletionCompleters.CompleteType(completionContext, "", "");
}
}
if ((list == null) || (list.Count == 0))
{
HashtableAst ast7 = lastAst as HashtableAst;
if (ast7 != null)
{
completionContext.ReplacementIndex = replacementIndex = completionContext.CursorPosition.Offset;
completionContext.ReplacementLength = replacementLength = 0;
list = CompletionCompleters.CompleteHashtableKey(completionContext, ast7);
}
}
if ((list == null) || (list.Count == 0))
{
string text = completionContext.RelatedAsts[0].Extent.Text;
if ((Regex.IsMatch(text, @"^[\S]+$") && (completionContext.RelatedAsts.Count > 0)) && (completionContext.RelatedAsts[0] is ScriptBlockAst))
{
replacementIndex = completionContext.RelatedAsts[0].Extent.StartScriptPosition.Offset;
replacementLength = completionContext.RelatedAsts[0].Extent.EndScriptPosition.Offset - replacementIndex;
completionContext.WordToComplete = text;
list = CompleteFileNameAsCommand(completionContext);
}
}
return(list);
}
public override AstVisitAction VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
Console.WriteLine("Visited an TypeExpressionAst.");
Console.WriteLine(" " + typeExpressionAst.ToString().Replace(Environment.NewLine, Environment.NewLine + " "));
return(AstVisitAction.Continue);
}
public object VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
Console.WriteLine("Visited an TypeExpressionAst.");
return(typeExpressionAst);
}
public object VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
return(typeExpressionAst.Copy());
}
public override AstVisitAction VisitTypeExpression(TypeExpressionAst ast)
{
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
TryFindTypeIncompatibilities(typeExpressionAst.TypeName);
return(AstVisitAction.SkipChildren);
}
public static TypeExpressionAst Update(this TypeExpressionAst ast, ITypeName typeName = null)
{
return(new TypeExpressionAst(ast.Extent, typeName ?? ast.TypeName));
}
object ICustomAstVisitor.VisitTypeExpression(TypeExpressionAst typeExpressionAst) => ProcessRewriter(VisitTypeExpression, typeExpressionAst);
public object VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
return(new TypeExpressionAst(typeExpressionAst.Extent, typeExpressionAst.TypeName));
}
public override ExpressionAst VisitTypeExpression(TypeExpressionAst typeExpressionAst) => VisitExpression(base.VisitTypeExpression(typeExpressionAst));
public override AstVisitAction VisitTypeExpression(TypeExpressionAst ast)
{
return(DoNextAction(ast));
}
public virtual object VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
return(typeExpressionAst);
}
public object VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
throw new UnexpectedElementException();
}
/// <summary>
/// Visit function and checks that it is a cmdlet. If yes, then checks that any object returns must have a type declared
/// in the output type (the only exception is if the type is object)
/// </summary>
/// <param name="funcAst"></param>
/// <returns></returns>
public override AstVisitAction VisitFunctionDefinition(FunctionDefinitionAst funcAst)
{
if (funcAst == null || funcAst.Body == null || funcAst.Body.ParamBlock == null ||
funcAst.Body.ParamBlock.Attributes == null || funcAst.Body.ParamBlock.Attributes.Count == 0 ||
!funcAst.Body.ParamBlock.Attributes.Any(attr => attr.TypeName.GetReflectionType() == typeof(CmdletBindingAttribute)))
{
return(AstVisitAction.Continue);
}
HashSet <string> outputTypes = new HashSet <string>();
foreach (AttributeAst attrAst in funcAst.Body.ParamBlock.Attributes)
{
if (attrAst.TypeName != null && attrAst.TypeName.GetReflectionType() == typeof(OutputTypeAttribute) &&
attrAst.PositionalArguments != null)
{
foreach (ExpressionAst expAst in attrAst.PositionalArguments)
{
if (expAst is StringConstantExpressionAst)
{
Type type = Type.GetType((expAst as StringConstantExpressionAst).Value);
if (type != null)
{
outputTypes.Add(type.FullName);
}
}
else
{
TypeExpressionAst typeAst = expAst as TypeExpressionAst;
if (typeAst != null && typeAst.TypeName != null)
{
if (typeAst.TypeName.GetReflectionType() != null)
{
outputTypes.Add(typeAst.TypeName.GetReflectionType().FullName);
}
else
{
outputTypes.Add(typeAst.TypeName.FullName);
}
}
}
}
}
}
#if PSV3
List <Tuple <string, StatementAst> > returnTypes = FindPipelineOutput.OutputTypes(funcAst);
#else
List <Tuple <string, StatementAst> > returnTypes = FindPipelineOutput.OutputTypes(funcAst, _classes);
#endif
HashSet <string> specialTypes = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
specialTypes.Add(typeof(Unreached).FullName);
specialTypes.Add(typeof(Undetermined).FullName);
specialTypes.Add(typeof(object).FullName);
specialTypes.Add(typeof(void).FullName);
specialTypes.Add(typeof(PSCustomObject).FullName);
specialTypes.Add(typeof(PSObject).FullName);
foreach (Tuple <string, StatementAst> returnType in returnTypes)
{
string typeName = returnType.Item1;
if (String.IsNullOrEmpty(typeName) ||
specialTypes.Contains(typeName) ||
outputTypes.Contains(typeName, StringComparer.OrdinalIgnoreCase))
{
continue;
}
else
{
DiagnosticRecords.Add(new DiagnosticRecord(string.Format(CultureInfo.CurrentCulture, Strings.UseOutputTypeCorrectlyError,
funcAst.Name, typeName), returnType.Item2.Extent, GetName(), DiagnosticSeverity.Information, fileName));
}
}
return(AstVisitAction.Continue);
}
/// <summary/> public virtual AstVisitAction VisitTypeExpression(TypeExpressionAst typeExpressionAst) => DefaultVisit(typeExpressionAst);
public object VisitTypeExpression(TypeExpressionAst typeExpressionAst) => null;
public object VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
throw new NotImplementedException();
}
public object VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
return(true);
}
public override AstVisitAction VisitTypeExpression(TypeExpressionAst typeExpressionAst)
{
throw new NotImplementedException(typeExpressionAst.ToString());
}
