/// <summary>
/// Condition on the parameter that must be satisfied for the error to be raised.
/// </summary>
/// <param name="CmdAst"></param>
/// <param name="CeAst"></param>
/// <returns></returns>
public override bool ParameterCondition(CommandAst CmdAst, CommandElementAst CeAst)
{
if (CeAst is CommandParameterAst)
{
CommandParameterAst cmdParamAst = CeAst as CommandParameterAst;
if (String.Equals(cmdParamAst.ParameterName, "computername", StringComparison.OrdinalIgnoreCase))
{
List<string> localhostRepresentations = new List<string> { "localhost", ".", "::1", "127.0.0.1" };
Ast computerNameArgument = GetComputerNameArg(CmdAst, cmdParamAst.Extent.StartOffset);
if (null != computerNameArgument)
{
if (!localhostRepresentations.Contains(computerNameArgument.Extent.Text.ToLower()))
{
return computerNameArgument is ConstantExpressionAst;
}
return false;
}
if (null != cmdParamAst.Argument && !localhostRepresentations.Contains(cmdParamAst.Argument.ToString().Replace("\"", "").Replace("'", "").ToLower()))
{
return cmdParamAst.Argument is ConstantExpressionAst;
}
}
}
return false;
}
private static string GetTestFixtureName(CommandAst testFixtureAst)
{
bool nextElementIsName = false;
foreach (var element in testFixtureAst.CommandElements)
{
if (
element is StringConstantExpressionAst &&
!(element as StringConstantExpressionAst).Value.Equals("TestFixture", StringComparison.OrdinalIgnoreCase) &&
!(element as StringConstantExpressionAst).Value.Equals("Name", StringComparison.OrdinalIgnoreCase))
{
return (element as StringConstantExpressionAst).Value;
}
if (nextElementIsName && element is StringConstantExpressionAst)
{
return (element as StringConstantExpressionAst).Value;
}
if (element is CommandParameterAst &&
(element as CommandParameterAst).ParameterName.Equals("Name", StringComparison.OrdinalIgnoreCase))
{
nextElementIsName = true;
}
}
throw new Exception("Failed to find test fixture name!");
}
public override AstVisitAction VisitCommand(CommandAst ast)
{
if (ast == usedAst)
used = true;
return AstVisitAction.Continue;
}
public static AssignmentStatementAst GetLastAssignmentStatementAst(this Ast ast, string varName, CommandAst usedAst)
{
var visitor = new FindLastAssignmentStatementVisitor(varName, usedAst);
ast.Visit(visitor);
return visitor.LastAssignmentStatementAst;
}
public FindLastAssignmentStatementVisitor(string varName, CommandAst usedAst)
{
this.varName = varName;
this.usedAst = usedAst;
used = false;
LastAssignmentStatementAst = null;
}
/// <summary>
/// Retrieves the error message
/// </summary>
/// <param name="FileName"></param>
/// <param name="CmdAst"></param>
/// <returns></returns>
public override string GetError(string FileName, CommandAst CmdAst)
{
if (CmdAst == null)
{
return string.Empty;
}
return string.Format(CultureInfo.CurrentCulture, Strings.AvoidComputerNameHardcodedError, CmdAst.GetCommandName());
}
/// <summary>
/// Checks to see if the command invocation is a dot
/// in order to find a dot sourced file
/// </summary>
/// <param name="commandAst">A CommandAst object in the script's AST</param>
/// <returns>A descion to stop searching if the right commandAst was found,
/// or a decision to continue if it wasn't found</returns>
public override AstVisitAction VisitCommand(CommandAst commandAst)
{
if (commandAst.InvocationOperator.Equals(TokenKind.Dot))
{
string fileName = commandAst.CommandElements[0].Extent.Text;
DotSourcedFiles.Add(fileName);
}
return base.VisitCommand(commandAst);
}
/// <summary>
/// Condition on the cmdlet that must be satisfied for the error to be raised
/// </summary>
/// <param name="CmdAst"></param>
/// <returns></returns>
public override bool CommandCondition(CommandAst CmdAst)
{
if (CTSTCmdlet == null)
{
CTSTCmdlet = Helper.Instance.CmdletNameAndAliases("convertto-securestring");
}
return CmdAst != null && CmdAst.GetCommandName() != null && CTSTCmdlet.Contains(CmdAst.GetCommandName(), StringComparer.OrdinalIgnoreCase);
}
private string GetParameterByNameOrPosition(string name, int position, CommandAst commandAst)
{
Dictionary<string, string> parameters = this.GetParameters(commandAst.CommandElements);
string str = null;
if (!parameters.TryGetValue(name, out str))
{
parameters.TryGetValue(position.ToString(CultureInfo.InvariantCulture), out str);
}
return str;
}
/// <summary>
/// Retrieves the error message
/// </summary>
/// <param name="FileName"></param>
/// <param name="CmdAst"></param>
/// <returns></returns>
public override string GetError(string fileName, CommandAst cmdAst)
{
if (String.IsNullOrWhiteSpace(fileName))
{
return String.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingConvertToSecureStringWithPlainTextErrorScriptDefinition);
}
else
{
return String.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingConvertToSecureStringWithPlainTextError, System.IO.Path.GetFileName(fileName));
}
}
/// <summary>
/// Decides if the current command is a reference of the symbol being searched for.
/// A reference of the symbol will be a of type SymbolType.Function
/// and have the same name as the symbol
/// </summary>
/// <param name="commandAst">A CommandAst in the script's AST</param>
/// <returns>A visit action that continues the search for references</returns>
public override AstVisitAction VisitCommand(CommandAst commandAst)
{
Ast commandNameAst = commandAst.CommandElements[0];
string commandName = commandNameAst.Extent.Text;
if(symbolRef.SymbolType.Equals(SymbolType.Function))
{
if (needsAliases)
{
// Try to get the commandAst's name and aliases,
// if a command does not exists (if the symbol isn't an alias to a command)
// set command to and empty string value string command
// if the aliases do not exist (if the symvol isn't a command that has aliases)
// set aliases to an empty List<string>
string command;
List<string> alaises;
CmdletToAliasDictionary.TryGetValue(commandName, out alaises);
AliasToCmdletDictionary.TryGetValue(commandName, out command);
if (alaises == null) { alaises = new List<string>(); }
if (command == null) { command = string.Empty; }
if (symbolRef.SymbolType.Equals(SymbolType.Function))
{
// Check if the found symbol's name is the same as the commandAst's name OR
// if the symbol's name is an alias for this commandAst's name (commandAst is a cmdlet) OR
// if the symbol's name is the same as the commandAst's cmdlet name (commandAst is a alias)
if (commandName.Equals(symbolRef.SymbolName, StringComparison.InvariantCultureIgnoreCase) ||
alaises.Contains(symbolRef.ScriptRegion.Text.ToLower()) ||
command.Equals(symbolRef.ScriptRegion.Text, StringComparison.InvariantCultureIgnoreCase) ||
(!command.Equals(string.Empty) && command.Equals(symbolRefCommandName, StringComparison.InvariantCultureIgnoreCase)))
{
this.FoundReferences.Add(new SymbolReference(
SymbolType.Function,
commandNameAst.Extent));
}
}
}
else // search does not include aliases
{
if (commandName.Equals(symbolRef.SymbolName, StringComparison.InvariantCultureIgnoreCase))
{
this.FoundReferences.Add(new SymbolReference(
SymbolType.Function,
commandNameAst.Extent));
}
}
}
return base.VisitCommand(commandAst);
}
private static FunctionDefinitionAst FindDefinition(CommandAst ast, Ast parentAst)
{
if (ast == null) throw new ArgumentNullException("ast");
if (parentAst == null) return null;
var definitions = parentAst.FindAll(
m => m is FunctionDefinitionAst && ((FunctionDefinitionAst) m).Name.Equals(ast.GetCommandName()), false).ToList();
if (definitions.Any())
{
return definitions.Last() as FunctionDefinitionAst;
}
return FindDefinition(ast, parentAst.Parent);
}
private static IEnumerable<string> GetLegacyTopLevelParametersFromAst(CommandAst ast, string parameterName)
{
var parameters = new List<string>();
IEnumerable<CommandParameterAst> commandElement =
ast.CommandElements.Where(x => IsParameterName(x, parameterName)).OfType<CommandParameterAst>();
foreach (var commandElementAst in commandElement)
{
var arrayLiteralAst = commandElementAst.Argument as ArrayLiteralAst;
if (arrayLiteralAst != null)
{
parameters.AddRange(arrayLiteralAst.Elements.OfType<StringConstantExpressionAst>().Select(x => x.Value));
}
}
return parameters;
}
private Ast GetComputerNameArg(CommandAst CmdAst, int StartIndex)
{
int small = int.MaxValue;
Ast computerNameArg = null;
foreach (Ast ast in CmdAst.CommandElements)
{
if (ast.Extent.StartOffset > StartIndex && ast.Extent.StartOffset < small)
{
computerNameArg = ast;
small = ast.Extent.StartOffset;
}
}
return computerNameArg;
}
public override AstVisitAction VisitCommand(CommandAst commandAst)
{
if (commandAst.InvocationOperator == TokenKind.Dot)
{
ThrowError(new ScriptBlockToPowerShellNotSupportedException("CantConvertWithDotSourcing", null, AutomationExceptions.CantConvertWithDotSourcing, new object[0]), commandAst);
}
if (commandAst.Parent.Parent.Parent != this.ScriptBeingConverted)
{
ThrowError(new ScriptBlockToPowerShellNotSupportedException("CantConvertWithCommandInvocations", null, AutomationExceptions.CantConvertWithCommandInvocations, new object[0]), commandAst);
}
if (commandAst.CommandElements[0] is ScriptBlockExpressionAst)
{
ThrowError(new ScriptBlockToPowerShellNotSupportedException("CantConvertWithScriptBlockInvocation", null, AutomationExceptions.CantConvertWithScriptBlockInvocation, new object[0]), commandAst);
}
return AstVisitAction.Continue;
}
/// <summary>
/// Checks to see if this command ast is the symbol we are looking for.
/// </summary>
/// <param name="commandAst">A CommandAst object in the script's AST</param>
/// <returns>A descion to stop searching if the right symbol was found,
/// or a decision to continue if it wasn't found</returns>
public override AstVisitAction VisitCommand(CommandAst commandAst)
{
Ast commandNameAst = commandAst.CommandElements[0];
if (this.IsPositionInExtent(commandNameAst.Extent))
{
this.FoundSymbolReference =
new SymbolReference(
SymbolType.Function,
commandNameAst.Extent);
return AstVisitAction.StopVisit;
}
return base.VisitCommand(commandAst);
}
public System.Object VisitCommand(System.Management.Automation.Language.CommandAst commandAst)
{
IScriptExtent mappedExtent = MapExtent(commandAst.Extent);
LinkedList <CommandElementAst> mappedCommandElements = new LinkedList <CommandElementAst>();
foreach (CommandElementAst ce in commandAst.CommandElements)
{
mappedCommandElements.AddLast(_VisitCommandElement(ce));
}
LinkedList <RedirectionAst> mappedRedirections = new LinkedList <RedirectionAst>();
foreach (RedirectionAst r in commandAst.Redirections)
{
mappedRedirections.AddLast(_VisitRedirection(r));
}
return(new CommandAst(mappedExtent, mappedCommandElements, commandAst.InvocationOperator, mappedRedirections));
}
/// <summary>
/// Checks that write-host command is not used
/// </summary>
/// <param name="cmdAst"></param>
/// <returns></returns>
public override AstVisitAction VisitCommand(CommandAst cmdAst)
{
if (cmdAst == null)
{
return AstVisitAction.SkipChildren;
}
if (cmdAst.GetCommandName() != null && String.Equals(cmdAst.GetCommandName(), "write-host", StringComparison.OrdinalIgnoreCase))
{
if (String.IsNullOrWhiteSpace(fileName))
{
records.Add(new DiagnosticRecord(String.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingWriteHostErrorScriptDefinition),
cmdAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName));
}
else
{
records.Add(new DiagnosticRecord(String.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingWriteHostError,
System.IO.Path.GetFileName(fileName)), cmdAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName));
}
}
return AstVisitAction.Continue;
}
public override AstVisitAction VisitCommand(CommandAst commandAst)
{
if (commandAst.InvocationOperator == TokenKind.Dot)
{
ThrowError(
new ScriptBlockToPowerShellNotSupportedException(
"CantConvertWithDotSourcing", null, AutomationExceptions.CantConvertWithDotSourcing),
commandAst);
}
// Up front checking ensures that we have a simple script block,
// so we can safely assume that the parents are:
// * a PipelineAst
// * a NamedBlockAst (the end block)
// * a ScriptBlockAst (the ast we're comparing to)
// If that isn't the case, the conversion isn't allowed. It
// is also safe to assume that we have at least 3 parents, a script block can't be simpler.
if (commandAst.Parent.Parent.Parent != ScriptBeingConverted)
{
ThrowError(
new ScriptBlockToPowerShellNotSupportedException(
"CantConvertWithCommandInvocations", null, AutomationExceptions.CantConvertWithCommandInvocations),
commandAst);
}
if (commandAst.CommandElements[0] is ScriptBlockExpressionAst)
{
ThrowError(
new ScriptBlockToPowerShellNotSupportedException(
"CantConvertWithScriptBlockInvocation", null,
AutomationExceptions.CantConvertWithScriptBlockInvocation),
commandAst);
}
return AstVisitAction.Continue;
}
public override AstVisitAction VisitCommand(CommandAst commandAst)
{
var commandName = commandAst.GetCommandName();
if (commandName != null)
{
if (_singleton._engineIntrinsics != null)
{
var commandInfo = _singleton._engineIntrinsics.InvokeCommand.GetCommand(commandName, CommandTypes.All);
if (commandInfo == null && !_singleton.UnresolvedCommandCouldSucceed(commandName, _rootAst))
{
_singleton._current = commandAst.CommandElements[0].Extent.EndOffset;
detectedError = string.Format(CultureInfo.CurrentCulture, PSReadLineResources.CommandNotFoundError, commandName);
return AstVisitAction.StopVisit;
}
}
if (commandAst.CommandElements.Any(e => e is ScriptBlockExpressionAst))
{
if (_singleton._options.CommandsToValidateScriptBlockArguments == null ||
!_singleton._options.CommandsToValidateScriptBlockArguments.Contains(commandName))
{
return AstVisitAction.SkipChildren;
}
}
}
if (_singleton._options.CommandValidationHandler != null)
{
try
{
_singleton._options.CommandValidationHandler(commandAst);
}
catch (Exception e)
{
detectedError = e.Message;
}
}
return !string.IsNullOrWhiteSpace(detectedError)
? AstVisitAction.StopVisit
: AstVisitAction.Continue;
}
public override AstVisitAction VisitCommand(CommandAst ast)
{
return(this.Check(ast));
}
Command GetCommand(CommandAst commandAst)
{
if (commandAst.CommandElements.First() is ScriptBlockExpressionAst)
{
var scriptBlockAst = (commandAst.CommandElements.First() as ScriptBlockExpressionAst).ScriptBlock;
return new Command(scriptBlockAst);
}
else
{
return new Command(commandAst.GetCommandName());
}
}
public override AstVisitAction VisitCommand(CommandAst commandAst)
{
if (commandAst.InvocationOperator == TokenKind.Dot) throw new NotImplementedException(commandAst.ToString());
Pipeline pipeline = this._context.CurrentRunspace.CreateNestedPipeline();
pipeline.Input.Write(this._context.inputStreamReader.ReadToEnd(), true);
var command = GetCommand(commandAst);
commandAst.CommandElements
// the first CommandElements is the command itself. The rest are parameters/arguments
.Skip(1)
.Select(ConvertCommandElementToCommandParameter)
.ForEach(command.Parameters.Add);
pipeline.Commands.Add(command);
this._context.PushPipeline(pipeline);
try
{
// TODO: develop a rational model for null/singleton/collection
var result = pipeline.Invoke();
if (result.Any())
{
this._pipelineCommandRuntime.WriteObject(result, true);
}
}
finally
{
this._context.PopPipeline();
}
return AstVisitAction.SkipChildren;
}
public override AstVisitAction VisitCommand(CommandAst commandAst)
{
if (commandAst.InvocationOperator == TokenKind.Dot)
return VisitDotSourceCommand(commandAst);
// Pipeline uses global execution context, so we should set its WriteSideEffects flag, and restore it to previous value after.
var pipeLineContext = _context.CurrentRunspace.ExecutionContext;
bool writeSideEffects = pipeLineContext.WriteSideEffectsToPipeline;
try
{
pipeLineContext.WriteSideEffectsToPipeline = _writeSideEffectsToPipeline;
var pipeline = _context.CurrentRunspace.CreateNestedPipeline();
pipeline.Input.Write(_context.inputStreamReader.ReadToEnd(), true);
var command = GetCommand(commandAst);
commandAst.CommandElements
// the first CommandElements is the command itself. The rest are parameters/arguments
.Skip(1)
.Select(ConvertCommandElementToCommandParameter)
.ForEach(command.Parameters.Add);
pipeline.Commands.Add(command);
_context.PushPipeline(pipeline);
try
{
// TODO: develop a rational model for null/singleton/collection
var result = pipeline.Invoke();
if (result.Any())
{
_pipelineCommandRuntime.WriteObject(result, true);
}
}
finally
{
_context.PopPipeline();
}
}
finally
{
pipeLineContext.WriteSideEffectsToPipeline = writeSideEffects;
}
return AstVisitAction.SkipChildren;
}
private AstVisitAction VisitDotSourceCommand(CommandAst commandAst)
{
object scriptFileName = EvaluateAst(commandAst.Children.First());
ScriptBlockAst ast = PowerShellGrammar.ParseInteractiveInput(File.ReadAllText(scriptFileName.ToString()));
ast.Visit(this);
return AstVisitAction.SkipChildren;
}
public object VisitCommand(CommandAst commandAst)
{
return(AutomationNull.Value);
}
/// <summary/> public virtual AstVisitAction VisitCommand(CommandAst commandAst) => DefaultVisit(commandAst);
/// <summary/>
public virtual object VisitCommand(CommandAst commandAst)
{
return(null);
}
public object VisitCommand(CommandAst commandAst)
{
return false;
}
/// <summary>
/// Condition on the parameter that must be satisfied for the error to be raised.
/// </summary>
/// <param name="CmdAst"></param>
/// <param name="CeAst"></param>
/// <returns></returns>
public override bool ParameterCondition(CommandAst CmdAst, CommandElementAst CeAst)
{
return CeAst is CommandParameterAst && String.Equals((CeAst as CommandParameterAst).ParameterName, "AsPlainText", StringComparison.OrdinalIgnoreCase);
}
/// <summary>
/// Return true if mandatory parameters are used OR the cmdlet does not exist
/// </summary>
/// <param name="cmdAst"></param>
/// <returns></returns>
private bool IsMandatoryParameterExisted(CommandAst cmdAst)
{
CommandInfo cmdInfo = null;
List<ParameterMetadata> mandParams = new List<ParameterMetadata>();
IEnumerable<CommandElementAst> ceAsts = null;
bool returnValue = false;
#region Predicates
// Predicate to find ParameterAsts.
Func<CommandElementAst, bool> foundParamASTs = delegate(CommandElementAst ceAst)
{
if (ceAst is CommandParameterAst) return true;
return false;
};
#endregion
#region Compares parameter list and mandatory parameter list.
cmdInfo = Helper.Instance.GetCommandInfo(Helper.Instance.GetCmdletNameFromAlias(cmdAst.GetCommandName()))
?? Helper.Instance.GetCommandInfo(cmdAst.GetCommandName());
if (cmdInfo == null || (cmdInfo.CommandType != System.Management.Automation.CommandTypes.Cmdlet))
{
return true;
}
// ignores if splatted variable is used
if (Helper.Instance.HasSplattedVariable(cmdAst))
{
return true;
}
// Gets parameters from command elements.
ceAsts = cmdAst.CommandElements.Where<CommandElementAst>(foundParamASTs);
// Gets mandatory parameters from cmdlet.
// If cannot find any mandatory parameter, it's not necessary to do a further check for current cmdlet.
try
{
int noOfParamSets = cmdInfo.ParameterSets.Count;
foreach (ParameterMetadata pm in cmdInfo.Parameters.Values)
{
int count = 0;
if (pm.Attributes.Count < noOfParamSets)
{
continue;
}
foreach (Attribute attr in pm.Attributes)
{
if (!(attr is ParameterAttribute)) continue;
if (((ParameterAttribute)attr).Mandatory)
{
count += 1;
}
}
if (count >= noOfParamSets)
{
mandParams.Add(pm);
}
}
}
catch (Exception)
{
// For cases like cmd.exe. Also for runtime exception
return true;
}
if (mandParams.Count() == 0 || Helper.Instance.PositionalParameterUsed(cmdAst))
{
returnValue = true;
}
else
{
// Compares parameter list and mandatory parameter list.
foreach (CommandElementAst ceAst in ceAsts)
{
CommandParameterAst cpAst = (CommandParameterAst)ceAst;
if (mandParams.Count<ParameterMetadata>(item =>
item.Name.Equals(cpAst.ParameterName, StringComparison.OrdinalIgnoreCase)) > 0)
{
returnValue = true;
break;
}
}
}
#endregion
return returnValue;
}
internal override IEnumerable <PSTypeName> GetInferredType(CompletionContext context)
{
if (this.VariablePath.IsVariable)
{
Ast parent = this.Parent;
if (this.VariablePath.IsUnqualified && (this.VariablePath.UserPath.Equals("_", StringComparison.Ordinal) || this.VariablePath.UserPath.Equals("PSItem", StringComparison.OrdinalIgnoreCase)))
{
while (parent != null)
{
if (parent is ScriptBlockExpressionAst)
{
break;
}
parent = parent.Parent;
}
if (parent != null)
{
if ((parent.Parent is CommandExpressionAst) && (parent.Parent.Parent is PipelineAst))
{
if (parent.Parent.Parent.Parent is HashtableAst)
{
parent = parent.Parent.Parent.Parent;
}
else if ((parent.Parent.Parent.Parent is ArrayLiteralAst) && (parent.Parent.Parent.Parent.Parent is HashtableAst))
{
parent = parent.Parent.Parent.Parent.Parent;
}
}
if (parent.Parent is CommandParameterAst)
{
parent = parent.Parent;
}
CommandAst iteratorVariable1 = parent.Parent as CommandAst;
if (iteratorVariable1 != null)
{
PipelineAst iteratorVariable2 = (PipelineAst)iteratorVariable1.Parent;
int iteratorVariable3 = iteratorVariable2.PipelineElements.IndexOf(iteratorVariable1) - 1;
if (iteratorVariable3 >= 0)
{
foreach (PSTypeName iteratorVariable4 in iteratorVariable2.PipelineElements[0].GetInferredType(context))
{
if (iteratorVariable4.Type != null)
{
if (iteratorVariable4.Type.IsArray)
{
yield return(new PSTypeName(iteratorVariable4.Type.GetElementType()));
continue;
}
if (typeof(IEnumerable).IsAssignableFrom(iteratorVariable4.Type))
{
IEnumerable <Type> iteratorVariable5 = from t in iteratorVariable4.Type.GetInterfaces()
where t.IsGenericType && t.GetGenericTypeDefinition().Equals(typeof(IEnumerable <>))
select t;
foreach (Type iteratorVariable6 in iteratorVariable5)
{
yield return(new PSTypeName(iteratorVariable6.GetGenericArguments()[0]));
}
continue;
}
}
yield return(iteratorVariable4);
}
}
goto Label_0833;
}
}
}
if (this.VariablePath.IsUnqualified)
{
for (int i = 0; i < SpecialVariables.AutomaticVariables.Length; i++)
{
if (this.VariablePath.UserPath.Equals(SpecialVariables.AutomaticVariables[i], StringComparison.OrdinalIgnoreCase))
{
Type type = SpecialVariables.AutomaticVariableTypes[i];
if (!type.Equals(typeof(object)))
{
yield return(new PSTypeName(type));
break;
}
break;
}
}
}
while (parent.Parent != null)
{
parent = parent.Parent;
}
if (parent.Parent is FunctionDefinitionAst)
{
parent = parent.Parent;
}
IEnumerable <Ast> source = AstSearcher.FindAll(parent, ast => (((ast is ParameterAst) || (ast is AssignmentStatementAst)) || (ast is ForEachStatementAst)) && this.AstAssignsToSameVariable(ast), true);
ParameterAst iteratorVariable10 = source.OfType <ParameterAst>().FirstOrDefault <ParameterAst>();
if (iteratorVariable10 != null)
{
PSTypeName[] iteratorVariable11 = iteratorVariable10.GetInferredType(context).ToArray <PSTypeName>();
if (iteratorVariable11.Length > 0)
{
foreach (PSTypeName iteratorVariable12 in iteratorVariable11)
{
yield return(iteratorVariable12);
}
goto Label_0833;
}
}
AssignmentStatementAst[] iteratorVariable13 = source.OfType <AssignmentStatementAst>().ToArray <AssignmentStatementAst>();
foreach (AssignmentStatementAst iteratorVariable14 in iteratorVariable13)
{
ConvertExpressionAst left = iteratorVariable14.Left as ConvertExpressionAst;
if ((left != null) && (left.StaticType != null))
{
yield return(new PSTypeName(left.StaticType));
goto Label_0833;
}
}
ForEachStatementAst iteratorVariable16 = source.OfType <ForEachStatementAst>().FirstOrDefault <ForEachStatementAst>();
if (iteratorVariable16 != null)
{
foreach (PSTypeName iteratorVariable17 in iteratorVariable16.Condition.GetInferredType(context))
{
yield return(iteratorVariable17);
}
}
else
{
int startOffset = this.Extent.StartOffset;
int iteratorVariable19 = 0x7fffffff;
AssignmentStatementAst iteratorVariable20 = null;
foreach (AssignmentStatementAst ast in iteratorVariable13)
{
int endOffset = ast.Extent.EndOffset;
if ((endOffset < startOffset) && ((startOffset - endOffset) < iteratorVariable19))
{
iteratorVariable19 = startOffset - endOffset;
iteratorVariable20 = ast;
}
}
if (iteratorVariable20 != null)
{
foreach (PSTypeName iteratorVariable21 in iteratorVariable20.Right.GetInferredType(context))
{
yield return(iteratorVariable21);
}
}
}
}
Label_0833:
yield break;
}
public override AstVisitAction VisitCommand(CommandAst ast)
{
return(CheckParent(ast));
}
public object VisitCommand(CommandAst commandAst)
{
return(false);
}
public virtual AstVisitAction VisitCommand(CommandAst commandAst)
{
return AstVisitAction.Continue;
}
/// <summary/>
public virtual AstVisitAction VisitCommand(CommandAst commandAst)
{
return(AstVisitAction.Continue);
}
/// <summary>
/// CompleteArgument
/// </summary>
public IEnumerable<CompletionResult> CompleteArgument(string commandName, string parameterName, string wordToComplete, CommandAst commandAst, IDictionary fakeBoundParameters)
{
var wordToCompletePattern = WildcardPattern.Get(string.IsNullOrWhiteSpace(wordToComplete) ? "*" : wordToComplete + "*", WildcardOptions.IgnoreCase);
foreach (var edition in Utils.AllowedEditionValues)
{
if (wordToCompletePattern.IsMatch(edition))
{
yield return new CompletionResult(edition, edition, CompletionResultType.Text, edition);
}
}
}
private static TestCase GetTestCase(CommandAst contextAst, string textFixtureName, string source)
{
var contextName = String.Empty;
var displayName = String.Empty;
bool nextElementIsName = false;
foreach (var element in contextAst.CommandElements)
{
if (
element is StringConstantExpressionAst &&
!(element as StringConstantExpressionAst).Value.Equals("TestCase", StringComparison.OrdinalIgnoreCase) &&
!(element as StringConstantExpressionAst).Value.Equals("Name", StringComparison.OrdinalIgnoreCase) &&
!(element as StringConstantExpressionAst).Value.Equals("ScriptBlock", StringComparison.OrdinalIgnoreCase))
{
contextName = String.Format("PSate||{0}||{1}", textFixtureName, (element as StringConstantExpressionAst).Value);
displayName = (element as StringConstantExpressionAst).Value;
break;
}
if (nextElementIsName && element is StringConstantExpressionAst)
{
contextName = String.Format("PSate||{0}||{1}", textFixtureName, (element as StringConstantExpressionAst).Value);
displayName = (element as StringConstantExpressionAst).Value;
break;
}
if (element is CommandParameterAst &&
(element as CommandParameterAst).ParameterName.Equals("Name", StringComparison.OrdinalIgnoreCase))
{
nextElementIsName = true;
}
}
var testcase = new TestCase(contextName, PowerShellTestExecutor.ExecutorUri, source)
{
CodeFilePath = source,
DisplayName = displayName,
LineNumber = contextAst.Extent.StartLineNumber,
LocalExtensionData = "PSate"
};
return testcase;
}
private void ConvertCommand(CommandAst commandAst, bool isTrustedInput)
{
// First need command name.
var commandName = GetCommandName(commandAst.CommandElements[0], isTrustedInput);
var command = new Command(commandName, isScript: false, useLocalScope: _createLocalScope);
// Handle redirections, if any (there can really be just 0 or 1).
if (commandAst.Redirections.Count > 0)
{
Diagnostics.Assert(commandAst.Redirections.Count == 1, "only 1 kind of redirection is supported");
Diagnostics.Assert(commandAst.Redirections[0] is MergingRedirectionAst, "unexpected redirection type");
PipelineResultTypes toType = PipelineResultTypes.Output;
PipelineResultTypes fromType;
switch (commandAst.Redirections[0].FromStream)
{
case RedirectionStream.Error:
fromType = PipelineResultTypes.Error;
break;
case RedirectionStream.Warning:
fromType = PipelineResultTypes.Warning;
break;
case RedirectionStream.Verbose:
fromType = PipelineResultTypes.Verbose;
break;
case RedirectionStream.Debug:
fromType = PipelineResultTypes.Debug;
break;
case RedirectionStream.Information:
fromType = PipelineResultTypes.Information;
break;
case RedirectionStream.All:
fromType = PipelineResultTypes.All;
break;
default:
// Default to Error->Output to be compatible with V2.
fromType = PipelineResultTypes.Error;
break;
}
command.MergeMyResults(fromType, toType);
}
_powershell.AddCommand(command);
// Now the parameters and arguments.
foreach (var ast in commandAst.CommandElements.Skip(1))
{
var exprAst = ast as ExpressionAst;
if (exprAst != null)
{
VariableExpressionAst variableAst = null;
var usingExprAst = ast as UsingExpressionAst;
if (usingExprAst != null)
{
string usingAstKey = PsUtils.GetUsingExpressionKey(usingExprAst);
object usingValue = _usingValueMap[usingAstKey];
variableAst = usingExprAst.SubExpression as VariableExpressionAst;
if (variableAst != null && variableAst.Splatted)
{
// Support the splatting of a dictionary
var parameters = usingValue as System.Collections.IDictionary;
if (parameters != null)
{
_powershell.AddParameters(parameters);
}
else
{
// Support the splatting of an array
var arguments = usingValue as System.Collections.IEnumerable;
if (arguments != null)
{
foreach (Object argument in arguments)
{
_powershell.AddArgument(argument);
}
}
else
{
// Splat the object directly.
_powershell.AddArgument(usingValue);
}
}
}
else
{
_powershell.AddArgument(usingValue);
}
continue;
}
variableAst = ast as VariableExpressionAst;
if (variableAst != null && variableAst.Splatted)
{
GetSplattedVariable(variableAst);
}
else
{
var constantExprAst = ast as ConstantExpressionAst;
object argument;
if (constantExprAst != null && LanguagePrimitives.IsNumeric(LanguagePrimitives.GetTypeCode(constantExprAst.StaticType)))
{
var commandArgumentText = constantExprAst.Extent.Text;
argument = constantExprAst.Value;
if (!commandArgumentText.Equals(constantExprAst.Value.ToString(), StringComparison.Ordinal))
{
// The wrapped number will actually return a PSObject which could end holding a reference to
// a typetable, making the object runspace specific. We should find a better way to avoid
// any possibility of sharing problems, though this is unlikely to cause problems.
argument = ParserOps.WrappedNumber(argument, commandArgumentText);
}
}
else
{
if (!isTrustedInput)
{
try
{
argument = GetSafeValueVisitor.GetSafeValue(exprAst, _context, GetSafeValueVisitor.SafeValueContext.GetPowerShell);
}
catch (System.Exception)
{
throw new ScriptBlockToPowerShellNotSupportedException(
"CantConvertWithDynamicExpression",
null,
AutomationExceptions.CantConvertWithDynamicExpression,
exprAst.Extent.Text);
}
}
else
{
argument = GetExpressionValue(exprAst, isTrustedInput);
}
}
_powershell.AddArgument(argument);
}
}
else
{
AddParameter((CommandParameterAst)ast, isTrustedInput);
}
}
}
public object VisitCommand(CommandAst commandAst)
{
throw PSTraceSource.NewArgumentException("ast");
}