public static VariableExpressionAst ExtractUsingVariable(UsingExpressionAst usingExpressionAst)
{
if (usingExpressionAst == null)
{
throw new ArgumentNullException("usingExpressionAst");
}
return(ExtractUsingVariableImpl(usingExpressionAst));
}
public System.Object VisitUsingExpression(System.Management.Automation.Language.UsingExpressionAst usingExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(usingExpressionAst.Extent);
ExpressionAst mappedExpressionAst = _VisitExpression(usingExpressionAst.SubExpression);
return(new UsingExpressionAst(mappedExtent, mappedExpressionAst));
}
public static VariableExpressionAst ExtractUsingVariable(UsingExpressionAst usingExpressionAst)
{
if (usingExpressionAst == null)
{
throw new ArgumentNullException("usingExpressionAst");
}
return ExtractUsingVariableImpl(usingExpressionAst);
}
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
if (usingExpressionAst.RuntimeUsingIndex == -1)
{
usingExpressionAst.RuntimeUsingIndex = this._runtimeUsingIndex;
}
this._runtimeUsingIndex++;
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
ExpressionAst subExpression = usingExpressionAst.SubExpression;
ExpressionAst ast2 = this.CheckUsingExpression(subExpression);
if (ast2 != null)
{
this._parser.ReportError(ast2.Extent, ParserStrings.InvalidUsingExpression, new object[0]);
}
return(AstVisitAction.Continue);
}
private static VariableExpressionAst ExtractUsingVariableImpl(ExpressionAst expression)
{
VariableExpressionAst subExpression;
UsingExpressionAst ast = expression as UsingExpressionAst;
if (ast != null)
{
subExpression = ast.SubExpression as VariableExpressionAst;
if (subExpression != null)
{
return(subExpression);
}
return(ExtractUsingVariableImpl(ast.SubExpression));
}
IndexExpressionAst ast3 = expression as IndexExpressionAst;
if (ast3 != null)
{
subExpression = ast3.Target as VariableExpressionAst;
if (subExpression != null)
{
return(subExpression);
}
return(ExtractUsingVariableImpl(ast3.Target));
}
MemberExpressionAst ast4 = expression as MemberExpressionAst;
if (ast4 == null)
{
return(null);
}
subExpression = ast4.Expression as VariableExpressionAst;
if (subExpression != null)
{
return(subExpression);
}
return(ExtractUsingVariableImpl(ast4.Expression));
}
/// <summary>
/// This method is to get the unique key for a UsingExpressionAst. The key is a base64
/// encoded string based on the text of the UsingExpressionAst.
///
/// This method is used when handling a script block that contains $using for Invoke-Command.
///
/// When run Invoke-Command targeting a machine that runs PSv3 or above, we pass a dictionary
/// to the remote end that contains the key of each UsingExpressionAst and its value. This method
/// is used to generate the key.
/// </summary>
/// <param name="usingAst">A using expression</param>
/// <returns>Base64 encoded string as the key of the UsingExpressionAst</returns>
internal static string GetUsingExpressionKey(Language.UsingExpressionAst usingAst)
{
Diagnostics.Assert(usingAst != null, "Caller makes sure the parameter is not null");
// We cannot call ToLowerInvariant unconditionally, because usingAst might
// contain IndexExpressionAst in its SubExpression, such as
// $using:bar["AAAA"]
// and the index "AAAA" might not get us the same value as "aaaa".
//
// But we do want a unique key to represent the same UsingExpressionAst's as much
// as possible, so as to avoid sending redundant key-value's to remote machine.
// As a workaround, we call ToLowerInvariant when the SubExpression of usingAst
// is a VariableExpressionAst, because:
// (1) Variable name is case insensitive;
// (2) People use $using to refer to a variable most of the time.
string usingAstText = usingAst.ToString();
if (usingAst.SubExpression is Language.VariableExpressionAst)
{
usingAstText = usingAstText.ToLowerInvariant();
}
return(StringToBase64Converter.StringToBase64String(usingAstText));
}
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
return null;
}
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
if (usingExpressionAst.RuntimeUsingIndex == -1)
{
usingExpressionAst.RuntimeUsingIndex = this._runtimeUsingIndex;
}
this._runtimeUsingIndex++;
return AstVisitAction.Continue;
}
/// <summary/> public virtual AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) => DefaultVisit(usingExpressionAst);
public static VariableExpressionAst ExtractUsingVariable(UsingExpressionAst usingExpressionAst)
{
throw new NotImplementedException(usingExpressionAst.ToString());
}
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
throw new NotImplementedException(); //VisitUsingExpression(usingExpressionAst);
}
/// <summary/>
public virtual object VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
return _decorated.VisitUsingExpression(usingExpressionAst);
}
/// <summary>
/// Check if the given UsingExpression is in a different scope from the previous UsingExpression that we analyzed.
/// </summary>
/// <remarks>
/// Note that the value of <paramref name="usingExpr"/> is retrieved by calling 'UsingExpressionAstSearcher.FindAllUsingExpressionExceptForWorkflow'.
/// So <paramref name="usingExpr"/> is guaranteed not inside a workflow.
/// </remarks>
/// <param name="usingExpr">The UsingExpression to analyze</param>
/// <param name="topLevelParent">The top level Ast, should be either ScriptBlockAst or FunctionDefinitionAst</param>
/// <param name="sbClosestToPreviousUsingExpr">The ScriptBlockAst that represents the scope of the previously analyzed UsingExpressions</param>
private static bool HasUsingExpressionsInDifferentScopes(UsingExpressionAst usingExpr, Ast topLevelParent, ref ScriptBlockAst sbClosestToPreviousUsingExpr)
{
Diagnostics.Assert(topLevelParent is ScriptBlockAst || topLevelParent is FunctionDefinitionAst,
"the top level parent should be either a ScriptBlockAst or FunctionDefinitionAst");
// Scan up the parents of a UsingExpression to check if it's in a nested function/filter/ScriptBlock
Ast current = usingExpr;
do
{
current = current.Parent;
var sbAst = current as ScriptBlockAst;
if (sbAst != null)
{
// We find the closest parent ScriptBlockAst of the current UsingExpression, which represents the scope
// that the current UsingExpression is in.
if (sbClosestToPreviousUsingExpr == null)
{
// The current UsingExpression is the first one to be analyzed.
sbClosestToPreviousUsingExpr = sbAst;
return false;
}
if (sbAst == sbClosestToPreviousUsingExpr)
{
// The current UsingExpression is in the same scope as the previous UsingExpression we analyzed.
return false;
}
// The current UsingExpression is in a different scope from the previous UsingExpression we analyzed.
return true;
}
var funcAst = current as FunctionDefinitionAst;
if (funcAst != null)
{
// The parent chain of the current UsingExpression reaches a FunctionDefinitionAst, then the UsingExpression
// must be in 'Parameters' property of this FunctionDefinitionAst.
// In this case, the 'Body' of this FunctionDefinitionAst represents the scope that the UsingExpression is in.
if (sbClosestToPreviousUsingExpr == null)
{
// The current UsingExpression is the first one to be analyzed.
sbClosestToPreviousUsingExpr = funcAst.Body;
return false;
}
if (funcAst.Body == sbClosestToPreviousUsingExpr)
{
// The current UsingExpression is in the same scope as the previous UsingExpression we analyzed.
return false;
}
// The current UsingExpression is in a different scope from the previous UsingExpression we analyzed.
return true;
}
} while (current != topLevelParent);
Diagnostics.Assert(false, "Unreachable Code. Top level parent is eitehr ScriptBlockAst or FunctionDefinitionAst, so it should return within the loop for sure.");
// I don't think it's reachable, but if it happens, just assume there are UsingExpressions in different scopes.
return true;
}
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
return false;
}
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
CheckIsConstant(usingExpressionAst.SubExpression, "Caller to verify ast is constant");
return usingExpressionAst.SubExpression.Accept(this);
}
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitUsingExpression(UsingExpressionAst ast)
{
return this.Check(ast);
}
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
throw new UnexpectedElementException();
}
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
// The parser will parse anything that could start with a variable when
// creating a UsingExpressionAst, but we will only support "simple"
// property and array references with no side effects.
var exprAst = usingExpressionAst.SubExpression;
var badExpr = CheckUsingExpression(exprAst);
if (badExpr != null)
{
_parser.ReportError(badExpr.Extent, () => ParserStrings.InvalidUsingExpression);
}
return AstVisitAction.Continue;
}
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
// Using expression is allowed if the sub-expression is allowed.
return AstVisitAction.Continue;
}
/// <summary>
/// Visit UsingExpression
/// </summary>
/// <param name="usingExpressionAst"></param>
/// <returns></returns>
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
// On the local machine, we may have set the index because of a call to ScriptBlockToPowerShell or Invoke-Command.
// On the remote machine, the index probably isn't set yet, so we set it here, mostly to avoid another pass
// over the ast. We assert below to ensure we're setting to the same value in both the local and remote cases.
// Cannot access the RuntimeUsingIndex
//if (usingExpressionAst.RuntimeUsingIndex == -1)
//{
// usingExpressionAst.RuntimeUsingIndex = _runtimeUsingIndex;
//}
//System.Diagnostics.Debug.Assert(usingExpressionAst.RuntimeUsingIndex == _runtimeUsingIndex, "Logic error in visiting using expressions.");
return AstVisitAction.Continue;
}
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
// $using:true should be safe - it's silly to write that, but not harmful.
return usingExpressionAst.SubExpression.Accept(this);
}
/// <summary>
/// Visit using expression
/// </summary>
/// <param name="usingExpressionAst"></param>
/// <returns></returns>
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
// The SubExpression is not visited, we treat this expression like it is a constant that is replaced
// before the script block is executed
return null;
}
public object VisitUsingExpression(UsingExpressionAst usingExpression)
{
return Expression.Call(CachedReflectionInfo.VariableOps_GetUsingValue, this.LocalVariablesParameter, ExpressionCache.Constant(usingExpression.RuntimeUsingIndex), _executionContextParameter);
}
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
// A using expression is always allowed, it simply gets re-written to be a parameter
HasUsingExpr = true;
// Skip the children - the expression is evaluated before sending to the remote machine,
// so it doesn't matter what we might find in the children.
return AstVisitAction.SkipChildren;
}
public override AstVisitAction VisitUsingExpression(UsingExpressionAst ast)
{
return(Check(ast));
}
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
return(usingExpressionAst.SubExpression.Accept(this));
}
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
// $using:true should be safe - it's silly to write that, but not harmful.
_visitCount++;
return(usingExpressionAst.SubExpression.Accept(this));
}
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
ExpressionAst subExpression = usingExpressionAst.SubExpression;
ExpressionAst ast2 = this.CheckUsingExpression(subExpression);
if (ast2 != null)
{
this._parser.ReportError(ast2.Extent, ParserStrings.InvalidUsingExpression, new object[0]);
}
return AstVisitAction.Continue;
}
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
// $using:true should be constant - it's silly to write that, but not harmful.
return(usingExpressionAst.SubExpression.Accept(this));
}
public virtual AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
return AstVisitAction.Continue;
}
public override AstVisitAction VisitUsingExpression(UsingExpressionAst ast) { return CheckParent(ast); }
internal static bool IsUsingExpressionInFunction(UsingExpressionAst usingExpr, Ast topLevelParent)
{
for (Ast ast = usingExpr.Parent; ast != null; ast = ast.Parent)
{
FunctionDefinitionAst ast2 = ast as FunctionDefinitionAst;
if ((ast2 != null) && !ast2.IsWorkflow)
{
return true;
}
if (ast == topLevelParent)
{
break;
}
}
return false;
}
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
this.HasUsingExpr = true;
return AstVisitAction.SkipChildren;
}
/// <summary/>
public virtual object VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
return(null);
}
public object VisitUsingExpression(UsingExpressionAst usingExpression)
{
string usingExprKey = PsUtils.GetUsingExpressionKey(usingExpression);
return Expression.Call(CachedReflectionInfo.VariableOps_GetUsingValue, LocalVariablesParameter,
Expression.Constant(usingExprKey),
ExpressionCache.Constant(usingExpression.RuntimeUsingIndex),
_executionContextParameter);
}
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
return usingExpressionAst.SubExpression.Accept(this);
}
public static VariableExpressionAst ExtractUsingVariable(UsingExpressionAst usingExpressionAst)
{
throw new NotImplementedException(usingExpressionAst.ToString());
}
/// <summary/>
public virtual AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
return AstVisitAction.Continue;
}
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
CheckIsConstant(usingExpressionAst.SubExpression, "Caller to verify ast is constant");
return(usingExpressionAst.SubExpression.Accept(this));
}
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst)
{
throw new NotImplementedException();
}
