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); }
/// <summary> /// Get using values as dictionary for the Foreach-Object parallel cmdlet. /// Ignore any using expressions that are associated with inner nested Foreach-Object parallel calls, /// since they are only effective in the nested call scope and not the current outer scope. /// </summary> /// <param name = "scriptBlock">Scriptblock to search.</param> /// <param name = "isTrustedInput">True when input is trusted.</param> /// <param name = "context">Execution context.</param> /// <param name = "foreachNames">List of foreach command names and aliases.</param> /// <returns>Dictionary of using variable map.</returns> internal static Dictionary <string, object> GetUsingValuesForEachParallel( ScriptBlock scriptBlock, bool isTrustedInput, ExecutionContext context, string[] foreachNames) { // Using variables for Foreach-Object -Parallel use are restricted to be within the // Foreach-Object -Parallel call scope. This will filter the using variable map to variables // only within the current (outer) Foreach-Object -Parallel call scope. var usingAsts = UsingExpressionAstSearcher.FindAllUsingExpressions(scriptBlock.Ast).ToList(); UsingExpressionAst usingAst = null; var usingValueMap = new Dictionary <string, object>(usingAsts.Count); Version oldStrictVersion = null; try { if (context != null) { oldStrictVersion = context.EngineSessionState.CurrentScope.StrictModeVersion; context.EngineSessionState.CurrentScope.StrictModeVersion = PSVersionInfo.PSVersion; } for (int i = 0; i < usingAsts.Count; ++i) { usingAst = (UsingExpressionAst)usingAsts[i]; if (IsInForeachParallelCallingScope(usingAst, foreachNames)) { var value = Compiler.GetExpressionValue(usingAst.SubExpression, isTrustedInput, context); string usingAstKey = PsUtils.GetUsingExpressionKey(usingAst); usingValueMap.TryAdd(usingAstKey, value); } } } catch (RuntimeException rte) { if (rte.ErrorRecord.FullyQualifiedErrorId.Equals("VariableIsUndefined", StringComparison.Ordinal)) { throw InterpreterError.NewInterpreterException( targetObject: null, exceptionType: typeof(RuntimeException), errorPosition: usingAst.Extent, resourceIdAndErrorId: "UsingVariableIsUndefined", resourceString: AutomationExceptions.UsingVariableIsUndefined, args: rte.ErrorRecord.TargetObject); } } finally { if (context != null) { context.EngineSessionState.CurrentScope.StrictModeVersion = oldStrictVersion; } } return(usingValueMap); }
/// <summary> /// Remove the "Using" prefix for all UsingExpressionAsts that appear in the given script /// </summary> /// <param name="script">script text</param> /// <param name="allWorkflowVariables">all workflow variables/arguments that potentially can be referred by a using variable</param> /// <param name="usingVariables">names of the variables in the script that have the "Using" prefix</param> /// <returns> /// Return <para>script</para> if the script text is empty string or null /// Return <para>script</para> if there are errors when parsing the script text /// Return <para>script</para> if there is no UsingExpressionAst in the given script /// Return a new script text that has all the "Using" prefixes removed /// </returns> private static string RemoveUsingPrefix(string script, HashSet <string> allWorkflowVariables, out HashSet <string> usingVariables) { usingVariables = new HashSet <string>(StringComparer.OrdinalIgnoreCase); var usingAsts = GetUsingExpressionAsts(script); if (usingAsts == null || !usingAsts.Any()) { return(script); } StringBuilder newScript = null; int startOffset = 0; foreach (Ast ast in usingAsts) { var usingAst = ast as UsingExpressionAst; if (usingAst == null) { continue; } VariableExpressionAst variableAst = UsingExpressionAst.ExtractUsingVariable(usingAst); if (variableAst == null) { continue; } if (newScript == null) { newScript = new StringBuilder(); } string varName = variableAst.VariablePath.UserPath; string varSign = variableAst.Splatted ? "@" : "$"; bool needPrefix = allWorkflowVariables.Contains(varName); string newVar = needPrefix ? (varSign + VariablePrefix + varName) : (varSign + varName); // Add those variable names that potentially refer to workflow variables/arguments if (needPrefix && !usingVariables.Contains(varName)) { usingVariables.Add(varName); } newScript.Append(script.Substring(startOffset, variableAst.Extent.StartOffset - startOffset)); newScript.Append(newVar); startOffset = variableAst.Extent.EndOffset; } if (newScript != null) { newScript.Append(script.Substring(startOffset)); return(newScript.ToString()); } return(script); }
/// <summary> /// This method creates a dictionary key for a Using expression value that is bound to /// a thread job script block parameter. PowerShell version 5.0+ recognizes this and performs /// the correct Using parameter argument binding. /// </summary> /// <param name="usingAst">A using expression</param> /// <returns>Base64 encoded string as the key of the UsingExpressionAst</returns> private static string GetUsingExpressionKey(UsingExpressionAst usingAst) { string usingAstText = usingAst.ToString(); if (usingAst.SubExpression is VariableExpressionAst) { usingAstText = usingAstText.ToLowerInvariant(); } return(Convert.ToBase64String(Encoding.Unicode.GetBytes(usingAstText.ToCharArray()))); }
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); }
private List <VariableExpressionAst> GetUsingVariables(System.Management.Automation.ScriptBlock localScriptBlock) { List <UsingExpressionAst> source = new List <UsingExpressionAst>(); foreach (Ast ast in UsingExpressionAstSearcher.FindAllUsingExpressionExceptForWorkflow(localScriptBlock.Ast).ToList <Ast>()) { UsingExpressionAst usingExpr = ast as UsingExpressionAst; if (ScriptBlockToPowerShellConverter.IsUsingExpressionInFunction(usingExpr, localScriptBlock.Ast)) { ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(AutomationExceptions.UsingVariableNotSupportedInFunctionOrFilter), "UsingVariableNotSupportedInFunctionOrFilter", ErrorCategory.InvalidOperation, ast); base.ThrowTerminatingError(errorRecord); } else { source.Add(usingExpr); } } return(source.Select <UsingExpressionAst, VariableExpressionAst>(new Func <UsingExpressionAst, VariableExpressionAst>(UsingExpressionAst.ExtractUsingVariable)).ToList <VariableExpressionAst>()); }
/// <summary> /// Walks the using Ast to verify it is used within a foreach-object -parallel command /// and parameter set scope, and not from within a nested foreach-object -parallel call. /// </summary> /// <param name="scriptblockAst">Scriptblock Ast containing this using Ast</param> /// <param name="usingAst">Using Ast to check.</param> /// <returns>True if using expression is in current call scope.</returns> private static bool IsInForeachParallelCallingScope( Ast scriptblockAst, UsingExpressionAst usingAst) { Diagnostics.Assert(usingAst != null, "usingAst argument cannot be null."); /* * Example: * $Test1 = "Hello" * 1 | ForEach-Object -Parallel { * $using:Test1 * $Test2 = "Goodbye" * 1 | ForEach-Object -Parallel { * $using:Test1 # Invalid using scope * $using:Test2 # Valid using scope * } * } */ // Search up the parent Ast chain for 'Foreach-Object -Parallel' commands. Ast currentParent = usingAst.Parent; while (currentParent != scriptblockAst) { // Look for Foreach-Object outer commands if (currentParent is CommandAst commandAst && FindForEachInCommand(commandAst)) { // Using Ast is outside the invoking foreach scope. return(false); } currentParent = currentParent.Parent; } return(true); }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { Console.WriteLine("Visited an UsingExpressionAst."); Console.WriteLine(" " + usingExpressionAst.ToString().Replace(Environment.NewLine, Environment.NewLine + " ")); return(AstVisitAction.Continue); }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { // TODO: add using expression explanation AstExplainer(usingExpressionAst); return(base.VisitUsingExpression(usingExpressionAst)); }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { var expressionAst = VisitAst(usingExpressionAst.SubExpression); return(new UsingExpressionAst(usingExpressionAst.Extent, expressionAst)); }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { Console.WriteLine("Visited an UsingExpressionAst."); return(usingExpressionAst); }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { throw new NotImplementedException(); }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) => null;
/// <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 override AstVisitAction VisitUsingExpression(UsingExpressionAst ast) { return(DoNextAction(ast)); }
private void ConvertCommand(CommandAst commandAst) { Command command = new Command(this.GetCommandName(commandAst.CommandElements[0]), false, this._createLocalScope); if (commandAst.Redirections.Count > 0) { PipelineResultTypes all; PipelineResultTypes output = PipelineResultTypes.Output; switch (commandAst.Redirections[0].FromStream) { case RedirectionStream.All: all = PipelineResultTypes.All; break; case RedirectionStream.Error: all = PipelineResultTypes.Error; break; case RedirectionStream.Warning: all = PipelineResultTypes.Warning; break; case RedirectionStream.Verbose: all = PipelineResultTypes.Verbose; break; case RedirectionStream.Debug: all = PipelineResultTypes.Debug; break; default: all = PipelineResultTypes.Error; break; } command.MergeMyResults(all, output); } this._powershell.AddCommand(command); foreach (CommandElementAst ast in commandAst.CommandElements.Skip <CommandElementAst>(1)) { ExpressionAst exprAst = ast as ExpressionAst; if (exprAst != null) { VariableExpressionAst variableAst = null; UsingExpressionAst ast4 = ast as UsingExpressionAst; if (ast4 != null) { variableAst = ast4.SubExpression as VariableExpressionAst; if ((variableAst != null) && variableAst.Splatted) { IDictionary parameters = this._usingValues[ast4.RuntimeUsingIndex] as IDictionary; if (parameters != null) { this._powershell.AddParameters(parameters); } else { IEnumerable enumerable = this._usingValues[ast4.RuntimeUsingIndex] as IEnumerable; if (enumerable != null) { foreach (object obj2 in enumerable) { this._powershell.AddArgument(obj2); } } else { this._powershell.AddArgument(this._usingValues[ast4.RuntimeUsingIndex]); } } } else { this._powershell.AddArgument(this._usingValues[ast4.RuntimeUsingIndex]); } } else { variableAst = ast as VariableExpressionAst; if ((variableAst != null) && variableAst.Splatted) { this.GetSplattedVariable(variableAst); } else { object expressionValue; ConstantExpressionAst ast5 = ast as ConstantExpressionAst; if ((ast5 != null) && LanguagePrimitives.IsNumeric(LanguagePrimitives.GetTypeCode(ast5.StaticType))) { string text = ast5.Extent.Text; expressionValue = ast5.Value; if (!text.Equals(ast5.Value.ToString(), StringComparison.Ordinal)) { expressionValue = ParserOps.WrappedNumber(expressionValue, text); } } else { expressionValue = this.GetExpressionValue(exprAst); } this._powershell.AddArgument(expressionValue); } } } else { this.AddParameter((CommandParameterAst)ast); } } }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { this.HasUsingExpr = true; return(AstVisitAction.SkipChildren); }
public virtual object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { VisitElement(usingExpressionAst.SubExpression); return(usingExpressionAst); }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst ast) { return(AstVisitAction.Continue); }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { var newUsingExpr = VisitElement(usingExpressionAst.SubExpression); return(new UsingExpressionAst(usingExpressionAst.Extent, newUsingExpr)); }
public static UsingExpressionAst Update(this UsingExpressionAst ast, ExpressionAst expressionAst = null) { return(new UsingExpressionAst( ast.Extent, expressionAst?.Clone() ?? ast.SubExpression?.Clone())); }
/// <summary> /// Walks the using Ast to verify it is used within a foreach-object -parallel command /// and parameter set scope, and not from within a nested foreach-object -parallel call. /// </summary> /// <param name="usingAst">Using Ast to check.</param> /// <param name-"foreachNames">List of foreach-object command names.</param> /// <returns>True if using expression is in current call scope.</returns> private static bool IsInForeachParallelCallingScope( UsingExpressionAst usingAst, string[] foreachNames) { /* * Example: * $Test1 = "Hello" * 1 | ForEach-Object -Parallel { * $using:Test1 * $Test2 = "Goodbye" * 1 | ForEach-Object -Parallel { * $using:Test1 # Invalid using scope * $using:Test2 # Valid using scope * } * } */ Diagnostics.Assert(usingAst != null, "usingAst argument cannot be null."); // Search up the parent Ast chain for 'Foreach-Object -Parallel' commands. Ast currentParent = usingAst.Parent; int foreachNestedCount = 0; while (currentParent != null) { // Look for Foreach-Object outer commands if (currentParent is CommandAst commandAst) { foreach (var commandElement in commandAst.CommandElements) { if (commandElement is StringConstantExpressionAst commandName) { bool found = false; foreach (var foreachName in foreachNames) { if (commandName.Value.Equals(foreachName, StringComparison.OrdinalIgnoreCase)) { found = true; break; } } if (found) { // Verify this is foreach-object with parallel parameter set. var bindingResult = StaticParameterBinder.BindCommand(commandAst); if (bindingResult.BoundParameters.ContainsKey("Parallel")) { foreachNestedCount++; break; } } } } } if (foreachNestedCount > 1) { // This using expression Ast is outside the original calling scope. return(false); } currentParent = currentParent.Parent; } return(foreachNestedCount == 1); }
/// <summary/> public virtual AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) => DefaultVisit(usingExpressionAst);
public override ExpressionAst VisitUsingExpression(UsingExpressionAst usingExpressionAst) => VisitExpression(base.VisitUsingExpression(usingExpressionAst));
private static object[] GetUsingValues(Ast body, ExecutionContext context, Dictionary <string, object> variables, bool filterNonUsingVariables) { List <Ast> list = UsingExpressionAstSearcher.FindAllUsingExpressionExceptForWorkflow(body).ToList <Ast>(); object[] objArray = new object[list.Count]; HashSet <string> set = ((variables != null) && filterNonUsingVariables) ? new HashSet <string>() : null; UsingExpressionAst usingExpr = null; Version strictModeVersion = null; try { if (context != null) { strictModeVersion = context.EngineSessionState.CurrentScope.StrictModeVersion; context.EngineSessionState.CurrentScope.StrictModeVersion = PSVersionInfo.PSVersion; } for (int i = 0; i < objArray.Length; i++) { usingExpr = (UsingExpressionAst)list[i]; if (IsUsingExpressionInFunction(usingExpr, body)) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingExpr.Extent, "UsingVariableNotSupportedInFunctionOrFilter", AutomationExceptions.UsingVariableNotSupportedInFunctionOrFilter, new object[] { usingExpr }); } object obj2 = null; if (variables != null) { VariableExpressionAst subExpression = usingExpr.SubExpression as VariableExpressionAst; if (subExpression == null) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingExpr.Extent, "CantGetUsingExpressionValueWithSpecifiedVariableDictionary", AutomationExceptions.CantGetUsingExpressionValueWithSpecifiedVariableDictionary, new object[] { usingExpr.Extent.Text }); } string userPath = subExpression.VariablePath.UserPath; if (((userPath != null) && variables.TryGetValue(userPath, out obj2)) && (set != null)) { set.Add(userPath); } } else { obj2 = Compiler.GetExpressionValue(usingExpr.SubExpression, context, (IList)null); } objArray[i] = obj2; usingExpr.RuntimeUsingIndex = i; } } catch (RuntimeException exception) { if (exception.ErrorRecord.FullyQualifiedErrorId.Equals("VariableIsUndefined", StringComparison.Ordinal)) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingExpr.Extent, "UsingVariableIsUndefined", AutomationExceptions.UsingVariableIsUndefined, new object[] { exception.ErrorRecord.TargetObject }); } if (exception.ErrorRecord.FullyQualifiedErrorId.Equals("UsingVariableNotSupportedInFunctionOrFilter", StringComparison.Ordinal) || exception.ErrorRecord.FullyQualifiedErrorId.Equals("CantGetUsingExpressionValueWithSpecifiedVariableDictionary", StringComparison.Ordinal)) { throw; } } finally { if (context != null) { context.EngineSessionState.CurrentScope.StrictModeVersion = strictModeVersion; } } if (set != null) { foreach (string str2 in variables.Keys.ToArray <string>()) { if (!set.Contains(str2)) { variables.Remove(str2); } } } return(objArray); }
/// <summary> /// Collect values for UsingExpressions, in the form of a dictionary and an array. /// - The dictionary form is used when the remote server is PSv5 and later version for handling UsingExpression in Invoke-Command/Start-Job /// - The array form is used when the remote server is PSv3 and PSv4 for handling UsingExpression in Invoke-Command. /// </summary> /// <remarks> /// We still keep the array-form using values because we want to avoid any breaking changes when running Invoke-Command /// targeting PSv3 or PSv4 remote end -- if UsingExpressions are all in the same scope, then we still pass an array of using /// values to the remote end; otherwise, we will handle UsingExpression as if the remote end is PSv2. /// </remarks> /// <returns> /// A tuple of the dictionary-form and the array-form using values. /// If the array-form using value is null, then there are UsingExpressions used in different scopes. /// </returns> private static Tuple <Dictionary <string, object>, object[]> GetUsingValues(Ast body, bool isTrustedInput, ExecutionContext context, Dictionary <string, object> variables, bool filterNonUsingVariables) { Diagnostics.Assert(context != null || variables != null, "can't retrieve variables with no context and no variables"); var usingAsts = UsingExpressionAstSearcher.FindAllUsingExpressionExceptForWorkflow(body).ToList(); var usingValueArray = new object[usingAsts.Count]; var usingValueMap = new Dictionary <string, object>(usingAsts.Count); HashSet <string> usingVarNames = (variables != null && filterNonUsingVariables) ? new HashSet <string>() : null; // Used to check if the PSv3/PSv4 way of handling UsingExpression can continue to be used. bool hasUsingExprInDifferentScope = false; ScriptBlockAst sbClosestToPreUsingExpr = null; UsingExpressionAst usingAst = null; Version oldStrictVersion = null; try { if (context != null) { oldStrictVersion = context.EngineSessionState.CurrentScope.StrictModeVersion; context.EngineSessionState.CurrentScope.StrictModeVersion = PSVersionInfo.PSVersion; } for (int i = 0; i < usingAsts.Count; ++i) { usingAst = (UsingExpressionAst)usingAsts[i]; object value = null; // This happens only when GetUsingValues gets called outside the ScriptBlockToPowerShellConverter class if (!hasUsingExprInDifferentScope && HasUsingExpressionsInDifferentScopes(usingAst, body, ref sbClosestToPreUsingExpr)) { // If there are UsingExpressions in different scopes, the array-form using values will not be useful // even if the remote end is PSv3 or PSv4, because the way we handle using expression in PSv3 and PSv4 // doesn't support UsingExpression in different scopes. In this case, we will set the array-form using // value to be null before return. // // Note that this check only affect array-form using value. In PSv5, we change the way to handle UsingExpression // on both client and server sides. The dictionary-form using values is used and UsingExpression in different // scope is supported. hasUsingExprInDifferentScope = true; } if (variables != null) { var variableAst = usingAst.SubExpression as VariableExpressionAst; if (variableAst == null) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingAst.Extent, "CantGetUsingExpressionValueWithSpecifiedVariableDictionary", AutomationExceptions.CantGetUsingExpressionValueWithSpecifiedVariableDictionary, usingAst.Extent.Text); } string varName = variableAst.VariablePath.UserPath; if (varName != null && variables.TryGetValue(varName, out value) && usingVarNames != null) { usingVarNames.Add(varName); } } else { value = Compiler.GetExpressionValue(usingAst.SubExpression, isTrustedInput, context); } // Collect UsingExpression value as an array usingValueArray[i] = value; // Collect UsingExpression value as a dictionary string usingAstKey = PsUtils.GetUsingExpressionKey(usingAst); usingValueMap.TryAdd(usingAstKey, value); } } catch (RuntimeException rte) { if (rte.ErrorRecord.FullyQualifiedErrorId.Equals("VariableIsUndefined", StringComparison.Ordinal)) { throw InterpreterError.NewInterpreterException(null, typeof(RuntimeException), usingAst.Extent, "UsingVariableIsUndefined", AutomationExceptions.UsingVariableIsUndefined, rte.ErrorRecord.TargetObject); } else if (rte.ErrorRecord.FullyQualifiedErrorId.Equals("CantGetUsingExpressionValueWithSpecifiedVariableDictionary", StringComparison.Ordinal)) { throw; } } finally { if (context != null) { context.EngineSessionState.CurrentScope.StrictModeVersion = oldStrictVersion; } } if (usingVarNames != null) { string[] keys = variables.Keys.ToArray(); foreach (string key in keys) { if (!usingVarNames.Contains(key)) { variables.Remove(key); } } } if (hasUsingExprInDifferentScope) { usingValueArray = null; } return(Tuple.Create(usingValueMap, usingValueArray)); }
public override AstVisitAction VisitUsingExpression(UsingExpressionAst usingExpressionAst) { throw new NotImplementedException(); //VisitUsingExpression(usingExpressionAst); }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { // $using:true should be safe - it's silly to write that, but not harmful. return(usingExpressionAst.SubExpression.Accept(this)); }
public object VisitUsingExpression(UsingExpressionAst usingExpressionAst) { throw new UnexpectedElementException(); }