public static bool IsConstant(Ast ast, out object constantValue, bool forAttribute = false, bool forRequires = false)
{
try
{
IsConstantValueVisitor visitor2 = new IsConstantValueVisitor {
CheckingAttributeArgument = forAttribute,
CheckingRequiresArgument = forRequires
};
if ((bool)ast.Accept(visitor2))
{
Ast parent = ast.Parent;
while (parent != null)
{
if (parent is DataStatementAst)
{
break;
}
parent = parent.Parent;
}
if (parent == null)
{
ConstantValueVisitor visitor = new ConstantValueVisitor {
AttributeArgument = forAttribute,
RequiresArgument = forRequires
};
constantValue = ast.Accept(visitor);
return(true);
}
}
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
}
constantValue = null;
return(false);
}
public static bool IsConstant(Ast ast, out object constantValue, bool forAttribute = false, bool forRequires = false)
{
try
{
IsConstantValueVisitor visitor2 = new IsConstantValueVisitor {
CheckingAttributeArgument = forAttribute,
CheckingRequiresArgument = forRequires
};
if ((bool) ast.Accept(visitor2))
{
Ast parent = ast.Parent;
while (parent != null)
{
if (parent is DataStatementAst)
{
break;
}
parent = parent.Parent;
}
if (parent == null)
{
ConstantValueVisitor visitor = new ConstantValueVisitor {
AttributeArgument = forAttribute,
RequiresArgument = forRequires
};
constantValue = ast.Accept(visitor);
return true;
}
}
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
}
constantValue = null;
return false;
}
private Action<List<Expression>, Expression> GetSwitchBodyGenerator(SwitchStatementAst switchStatementAst, AutomaticVarSaver avs, ParameterExpression skipDefault)
{
return (exprs, newValue) =>
{
var clauseEvalBinder = PSSwitchClauseEvalBinder.Get(switchStatementAst.Flags);
exprs.Add(avs.SetNewValue(newValue));
if (skipDefault != null)
{
exprs.Add(Expression.Assign(skipDefault, ExpressionCache.Constant(false)));
}
IsConstantValueVisitor iscvv = new IsConstantValueVisitor();
ConstantValueVisitor cvv = new ConstantValueVisitor();
int clauseCount = switchStatementAst.Clauses.Count;
for (int i = 0; i < clauseCount; i++)
{
var clause = switchStatementAst.Clauses[i];
Expression test;
object constValue = ((bool)clause.Item1.Accept(iscvv)) ? clause.Item1.Accept(cvv) : null;
if (constValue is ScriptBlock)
{
var call = Expression.Call(Expression.Constant(constValue),
CachedReflectionInfo.ScriptBlock_DoInvokeReturnAsIs,
/*useLocalScope=*/ ExpressionCache.Constant(true),
/*errorHandlingBehavior=*/ Expression.Constant(ScriptBlock.ErrorHandlingBehavior.WriteToExternalErrorPipe),
/*dollarUnder=*/ GetLocal((int)AutomaticVariable.Underbar).Convert(typeof(object)),
/*input=*/ ExpressionCache.AutomationNullConstant,
/*scriptThis=*/ ExpressionCache.AutomationNullConstant,
/*args=*/ ExpressionCache.NullObjectArray);
test = DynamicExpression.Dynamic(PSConvertBinder.Get(typeof(bool)), typeof(bool), call);
}
else if (constValue != null)
{
SwitchFlags flags = switchStatementAst.Flags;
Expression conditionExpr = constValue is Regex || constValue is WildcardPattern
? (Expression)Expression.Constant(constValue)
: DynamicExpression.Dynamic(PSToStringBinder.Get(), typeof(string),
(constValue is Type)
? Expression.Constant(constValue, typeof(Type))
: Expression.Constant(constValue),
_executionContextParameter);
Expression currentAsString =
DynamicExpression.Dynamic(PSToStringBinder.Get(), typeof(string), GetLocal((int)AutomaticVariable.Underbar),
_executionContextParameter);
if ((flags & SwitchFlags.Regex) != 0 || constValue is Regex)
{
test = Expression.Call(CachedReflectionInfo.SwitchOps_ConditionSatisfiedRegex,
/*caseSensitive=*/ ExpressionCache.Constant((flags & SwitchFlags.CaseSensitive) != 0),
/*condition=*/ conditionExpr,
/*errorPosition=*/ Expression.Constant(clause.Item1.Extent),
/*str=*/ currentAsString,
/*context=*/ _executionContextParameter);
}
else if ((flags & SwitchFlags.Wildcard) != 0 || constValue is WildcardPattern)
{
// It would be a little better to just build the wildcard at compile time, but
// the runtime method must exist when variable cases are involved.
test = Expression.Call(CachedReflectionInfo.SwitchOps_ConditionSatisfiedWildcard,
/*caseSensitive=*/ ExpressionCache.Constant((flags & SwitchFlags.CaseSensitive) != 0),
/*condition=*/ conditionExpr,
/*str=*/ currentAsString,
/*context=*/ _executionContextParameter);
}
else
{
test = CallStringEquals(conditionExpr, currentAsString,
((flags & SwitchFlags.CaseSensitive) == 0));
}
}
else
{
var cond = Compile(clause.Item1);
test = DynamicExpression.Dynamic(clauseEvalBinder, typeof(bool),
cond, GetLocal((int)AutomaticVariable.Underbar), _executionContextParameter);
}
exprs.Add(UpdatePosition(clause.Item1));
if (skipDefault != null)
{
exprs.Add(Expression.IfThen(
test,
Expression.Block(Compile(clause.Item2),
Expression.Assign(skipDefault, ExpressionCache.Constant(true)))));
}
else
{
exprs.Add(Expression.IfThen(test, Compile(clause.Item2)));
}
}
if (skipDefault != null)
{
exprs.Add(Expression.IfThen(Expression.Not(skipDefault), Compile(switchStatementAst.Default)));
}
};
}
internal static Attribute GetAttribute(AttributeAst attributeAst)
{
var attributeType = attributeAst.TypeName.GetReflectionAttributeType();
if (attributeType == null)
{
throw InterpreterError.NewInterpreterException(attributeAst, typeof(RuntimeException), attributeAst.Extent,
"CustomAttributeTypeNotFound", ParserStrings.CustomAttributeTypeNotFound, attributeAst.TypeName.FullName);
}
Func<AttributeAst, Attribute> generator;
if (s_builtinAttributeGenerator.TryGetValue(attributeType, out generator))
{
return generator(attributeAst);
}
var positionalArgCount = attributeAst.PositionalArguments.Count;
var argumentNames = attributeAst.NamedArguments.Select(name => name.ArgumentName).ToArray();
var totalArgCount = positionalArgCount + argumentNames.Length;
var callInfo = new CallInfo(totalArgCount, argumentNames);
var delegateArgs = new object[totalArgCount + 1];
delegateArgs[0] = attributeType;
var cvv = new ConstantValueVisitor { AttributeArgument = true };
int i = 1;
for (int index = 0; index < attributeAst.PositionalArguments.Count; index++)
{
var posArg = attributeAst.PositionalArguments[index];
delegateArgs[i++] = posArg.Accept(cvv);
}
for (int index = 0; index < attributeAst.NamedArguments.Count; index++)
{
var namedArg = attributeAst.NamedArguments[index];
delegateArgs[i++] = namedArg.Argument.Accept(cvv);
}
try
{
return (Attribute)GetAttributeGenerator(callInfo).DynamicInvoke(delegateArgs);
}
catch (TargetInvocationException tie)
{
// Unwrap the wrapped exception
var innerException = tie.InnerException;
var rte = innerException as RuntimeException;
if (rte == null)
{
rte = InterpreterError.NewInterpreterExceptionWithInnerException(null, typeof(RuntimeException), attributeAst.Extent,
"ExceptionConstructingAttribute", ExtendedTypeSystem.ExceptionConstructingAttribute, innerException,
innerException.Message, attributeAst.TypeName.FullName);
}
InterpreterError.UpdateExceptionErrorRecordPosition(rte, attributeAst.Extent);
throw rte;
}
}
private static Attribute NewValidateSetAttribute(AttributeAst ast)
{
var cvv = new ConstantValueVisitor { AttributeArgument = true };
var args = new string[ast.PositionalArguments.Count];
for (int i = 0; i < ast.PositionalArguments.Count; i++)
{
args[i] = _attrArgToStringConverter.Target(_attrArgToStringConverter,
ast.PositionalArguments[i].Accept(cvv));
}
var result = new ValidateSetAttribute(args);
foreach (var namedArg in ast.NamedArguments)
{
var argValue = namedArg.Argument.Accept(cvv);
var argumentName = namedArg.ArgumentName;
if (argumentName.Equals("IgnoreCase", StringComparison.OrdinalIgnoreCase))
{
result.IgnoreCase = s_attrArgToBoolConverter.Target(s_attrArgToBoolConverter, argValue);
}
else
{
throw InterpreterError.NewInterpreterException(namedArg, typeof(RuntimeException), namedArg.Extent,
"PropertyNotFoundForType", ParserStrings.PropertyNotFoundForType, argumentName,
typeof(CmdletBindingAttribute));
}
}
return result;
}
private static Attribute NewAliasAttribute(AttributeAst ast)
{
CheckNoNamedArgs(ast);
var cvv = new ConstantValueVisitor { AttributeArgument = true };
var args = new string[ast.PositionalArguments.Count];
for (int i = 0; i < ast.PositionalArguments.Count; i++)
{
args[i] = _attrArgToStringConverter.Target(_attrArgToStringConverter,
ast.PositionalArguments[i].Accept(cvv));
}
return new AliasAttribute(args);
}
private static Attribute NewOutputTypeAttribute(AttributeAst ast)
{
var cvv = new ConstantValueVisitor { AttributeArgument = true };
OutputTypeAttribute result;
if (ast.PositionalArguments.Count == 0)
{
result = new OutputTypeAttribute(Utils.EmptyArray<string>());
}
else if (ast.PositionalArguments.Count == 1)
{
var typeArg = ast.PositionalArguments[0] as TypeExpressionAst;
if (typeArg != null)
{
var type = TypeOps.ResolveTypeName(typeArg.TypeName, typeArg.Extent);
result = new OutputTypeAttribute(type);
}
else
{
var argValue = ast.PositionalArguments[0].Accept(cvv);
result = new OutputTypeAttribute(_attrArgToStringConverter.Target(_attrArgToStringConverter, argValue));
}
}
else
{
var args = new object[ast.PositionalArguments.Count];
for (int i = 0; i < ast.PositionalArguments.Count; i++)
{
var positionalArgument = ast.PositionalArguments[i];
var typeArg = positionalArgument as TypeExpressionAst;
args[i] = typeArg != null
? TypeOps.ResolveTypeName(typeArg.TypeName, typeArg.Extent)
: positionalArgument.Accept(cvv);
}
if (args[0] is Type)
{
result = new OutputTypeAttribute(LanguagePrimitives.ConvertTo<Type[]>(args));
}
else
{
result = new OutputTypeAttribute(LanguagePrimitives.ConvertTo<string[]>(args));
}
}
foreach (var namedArg in ast.NamedArguments)
{
var argValue = namedArg.Argument.Accept(cvv);
var argumentName = namedArg.ArgumentName;
if (argumentName.Equals("ParameterSetName", StringComparison.OrdinalIgnoreCase))
{
result.ParameterSetName = s_attrArgToStringArrayConverter.Target(s_attrArgToStringArrayConverter, argValue);
}
else if (argumentName.Equals("ProviderCmdlet", StringComparison.OrdinalIgnoreCase))
{
result.ProviderCmdlet = _attrArgToStringConverter.Target(_attrArgToStringConverter, argValue);
}
else
{
throw InterpreterError.NewInterpreterException(namedArg, typeof(RuntimeException), namedArg.Extent,
"PropertyNotFoundForType", ParserStrings.PropertyNotFoundForType, argumentName,
typeof(CmdletBindingAttribute));
}
}
return result;
}
private static Attribute NewParameterAttribute(AttributeAst ast)
{
CheckNoPositionalArgs(ast);
var cvv = new ConstantValueVisitor { AttributeArgument = true };
var result = new ParameterAttribute();
foreach (var namedArg in ast.NamedArguments)
{
var argValue = namedArg.Argument.Accept(cvv);
var argumentName = namedArg.ArgumentName;
if (argumentName.Equals("Position", StringComparison.OrdinalIgnoreCase))
{
result.Position = s_attrArgToIntConverter.Target(s_attrArgToIntConverter, argValue);
}
else if (argumentName.Equals("ParameterSetName", StringComparison.OrdinalIgnoreCase))
{
result.ParameterSetName = _attrArgToStringConverter.Target(_attrArgToStringConverter, argValue);
}
else if (argumentName.Equals("Mandatory", StringComparison.OrdinalIgnoreCase))
{
result.Mandatory = s_attrArgToBoolConverter.Target(s_attrArgToBoolConverter, argValue);
}
else if (argumentName.Equals("ValueFromPipeline", StringComparison.OrdinalIgnoreCase))
{
result.ValueFromPipeline = s_attrArgToBoolConverter.Target(s_attrArgToBoolConverter, argValue);
}
else if (argumentName.Equals("ValueFromPipelineByPropertyName", StringComparison.OrdinalIgnoreCase))
{
result.ValueFromPipelineByPropertyName = s_attrArgToBoolConverter.Target(s_attrArgToBoolConverter, argValue);
}
else if (argumentName.Equals("ValueFromRemainingArguments", StringComparison.OrdinalIgnoreCase))
{
result.ValueFromRemainingArguments = s_attrArgToBoolConverter.Target(s_attrArgToBoolConverter, argValue);
}
else if (argumentName.Equals("HelpMessage", StringComparison.OrdinalIgnoreCase))
{
result.HelpMessage = _attrArgToStringConverter.Target(_attrArgToStringConverter, argValue);
}
else if (argumentName.Equals("HelpMessageBaseName", StringComparison.OrdinalIgnoreCase))
{
result.HelpMessageBaseName = _attrArgToStringConverter.Target(_attrArgToStringConverter, argValue);
}
else if (argumentName.Equals("HelpMessageResourceId", StringComparison.OrdinalIgnoreCase))
{
result.HelpMessageResourceId = _attrArgToStringConverter.Target(_attrArgToStringConverter, argValue);
}
else if (argumentName.Equals("DontShow", StringComparison.OrdinalIgnoreCase))
{
result.DontShow = s_attrArgToBoolConverter.Target(s_attrArgToBoolConverter, argValue);
}
else
{
throw InterpreterError.NewInterpreterException(namedArg, typeof(RuntimeException), namedArg.Extent,
"PropertyNotFoundForType", ParserStrings.PropertyNotFoundForType, argumentName,
typeof(CmdletBindingAttribute));
}
}
return result;
}
private static Attribute NewCmdletBindingAttribute(AttributeAst ast)
{
CheckNoPositionalArgs(ast);
var cvv = new ConstantValueVisitor { AttributeArgument = true };
var result = new CmdletBindingAttribute();
foreach (var namedArg in ast.NamedArguments)
{
var argValue = namedArg.Argument.Accept(cvv);
var argumentName = namedArg.ArgumentName;
if (argumentName.Equals("DefaultParameterSetName", StringComparison.OrdinalIgnoreCase))
{
result.DefaultParameterSetName = _attrArgToStringConverter.Target(_attrArgToStringConverter, argValue);
}
else if (argumentName.Equals("HelpUri", StringComparison.OrdinalIgnoreCase))
{
result.HelpUri = _attrArgToStringConverter.Target(_attrArgToStringConverter, argValue);
}
else if (argumentName.Equals("SupportsShouldProcess", StringComparison.OrdinalIgnoreCase))
{
result.SupportsShouldProcess = s_attrArgToBoolConverter.Target(s_attrArgToBoolConverter, argValue);
}
else if (argumentName.Equals("PositionalBinding", StringComparison.OrdinalIgnoreCase))
{
result.PositionalBinding = s_attrArgToBoolConverter.Target(s_attrArgToBoolConverter, argValue);
}
else if (argumentName.Equals("ConfirmImpact", StringComparison.OrdinalIgnoreCase))
{
result.ConfirmImpact = s_attrArgToConfirmImpactConverter.Target(s_attrArgToConfirmImpactConverter, argValue);
}
else if (argumentName.Equals("SupportsTransactions", StringComparison.OrdinalIgnoreCase))
{
result.SupportsTransactions = s_attrArgToBoolConverter.Target(s_attrArgToBoolConverter, argValue);
}
else if (argumentName.Equals("SupportsPaging", StringComparison.OrdinalIgnoreCase))
{
result.SupportsPaging = s_attrArgToBoolConverter.Target(s_attrArgToBoolConverter, argValue);
}
else if (argumentName.Equals("RemotingCapability", StringComparison.OrdinalIgnoreCase))
{
result.RemotingCapability = s_attrArgToRemotingCapabilityConverter.Target(s_attrArgToRemotingCapabilityConverter, argValue);
}
else
{
throw InterpreterError.NewInterpreterException(namedArg, typeof(RuntimeException), namedArg.Extent,
"PropertyNotFoundForType", ParserStrings.PropertyNotFoundForType, argumentName,
typeof(CmdletBindingAttribute));
}
}
return result;
}
} // GetFunction
private IEnumerable<string> GetFunctionAliases(IParameterMetadataProvider ipmp)
{
if (ipmp == null || ipmp.Body.ParamBlock == null)
yield break;
var attributes = ipmp.Body.ParamBlock.Attributes;
foreach (var attributeAst in attributes)
{
var attributeType = attributeAst.TypeName.GetReflectionAttributeType();
if (attributeType == typeof(AliasAttribute))
{
var cvv = new ConstantValueVisitor { AttributeArgument = true };
for (int i = 0; i < attributeAst.PositionalArguments.Count; i++)
{
yield return Compiler._attrArgToStringConverter.Target(Compiler._attrArgToStringConverter,
attributeAst.PositionalArguments[i].Accept(cvv));
}
}
}
}
private static CustomAttributeBuilder GetAttributeBuilder(Parser parser, AttributeAst attributeAst, AttributeTargets attributeTargets)
{
var attributeType = attributeAst.TypeName.GetReflectionAttributeType();
Diagnostics.Assert(attributeType != null, "Semantic checks should have verified attribute type exists");
Diagnostics.Assert(
attributeType.GetTypeInfo().GetCustomAttribute<AttributeUsageAttribute>(true) == null ||
(attributeType.GetTypeInfo().GetCustomAttribute<AttributeUsageAttribute>(true).ValidOn & attributeTargets) != 0, "Semantic checks should have verified attribute usage");
var positionalArgs = new object[attributeAst.PositionalArguments.Count];
var cvv = new ConstantValueVisitor { AttributeArgument = false };
for (var i = 0; i < attributeAst.PositionalArguments.Count; i++)
{
var posArg = attributeAst.PositionalArguments[i];
positionalArgs[i] = posArg.Accept(cvv);
}
var ctorInfos = attributeType.GetConstructors();
var newConstructors = DotNetAdapter.GetMethodInformationArray(ctorInfos);
string errorId = null;
string errorMsg = null;
bool expandParamsOnBest;
bool callNonVirtually;
var positionalArgCount = positionalArgs.Length;
var bestMethod = Adapter.FindBestMethod(newConstructors, null, positionalArgs, ref errorId, ref errorMsg, out expandParamsOnBest, out callNonVirtually);
if (bestMethod == null)
{
parser.ReportError(new ParseError(attributeAst.Extent, errorId,
string.Format(CultureInfo.InvariantCulture, errorMsg, attributeType.Name, attributeAst.PositionalArguments.Count)));
return null;
}
var constructorInfo = (ConstructorInfo)bestMethod.method;
var parameterInfo = constructorInfo.GetParameters();
var ctorArgs = new object[parameterInfo.Length];
object arg;
for (var argIndex = 0; argIndex < parameterInfo.Length; ++argIndex)
{
var resultType = parameterInfo[argIndex].ParameterType;
// The extension method 'CustomAttributeExtensions.GetCustomAttributes(ParameterInfo, Type, Boolean)' has inconsistent
// behavior on its return value in both FullCLR and CoreCLR. According to MSDN, if the attribute cannot be found, it
// should return an empty collection. However, it returns null in some rare cases [when the parameter isn't backed by
// actual metadata].
// This inconsistent behavior affects OneCore powershell because we are using the extension method here when compiling
// against CoreCLR. So we need to add a null check until this is fixed in CLR.
var paramArrayAttrs = parameterInfo[argIndex].GetCustomAttributes(typeof(ParamArrayAttribute), true);
if (paramArrayAttrs != null && paramArrayAttrs.Any() && expandParamsOnBest)
{
var elementType = parameterInfo[argIndex].ParameterType.GetElementType();
var paramsArray = Array.CreateInstance(elementType, positionalArgCount - argIndex);
ctorArgs[argIndex] = paramsArray;
for (var i = 0; i < paramsArray.Length; ++i, ++argIndex)
{
if (!TryConvertArg(positionalArgs[argIndex], elementType, out arg,
parser, attributeAst.PositionalArguments[argIndex].Extent))
{
return null;
}
paramsArray.SetValue(arg, i);
}
break;
}
if (!TryConvertArg(positionalArgs[argIndex], resultType, out arg,
parser, attributeAst.PositionalArguments[argIndex].Extent))
{
return null;
}
ctorArgs[argIndex] = arg;
}
if (attributeAst.NamedArguments.Count == 0)
{
return new CustomAttributeBuilder(constructorInfo, ctorArgs);
}
var propertyInfoList = new List<PropertyInfo>();
var propertyArgs = new List<object>();
var fieldInfoList = new List<FieldInfo>();
var fieldArgs = new List<object>();
foreach (var namedArg in attributeAst.NamedArguments)
{
var name = namedArg.ArgumentName;
var members = attributeType.GetMember(name, MemberTypes.Field | MemberTypes.Property,
BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
Diagnostics.Assert(members.Length == 1 && (members[0] is PropertyInfo || members[0] is FieldInfo),
"Semantic checks should have ensured names attribute argument exists");
arg = namedArg.Argument.Accept(cvv);
var propertyInfo = members[0] as PropertyInfo;
if (propertyInfo != null)
{
Diagnostics.Assert(propertyInfo.GetSetMethod() != null, "Semantic checks ensures property is settable");
if (!TryConvertArg(arg, propertyInfo.PropertyType, out arg, parser, namedArg.Argument.Extent))
{
return null;
}
propertyInfoList.Add(propertyInfo);
propertyArgs.Add(arg);
continue;
}
var fieldInfo = (FieldInfo)members[0];
Diagnostics.Assert(!fieldInfo.IsInitOnly && !fieldInfo.IsLiteral, "Semantic checks ensures field is settable");
if (!TryConvertArg(arg, fieldInfo.FieldType, out arg, parser, namedArg.Argument.Extent))
{
return null;
}
fieldInfoList.Add(fieldInfo);
fieldArgs.Add(arg);
}
return new CustomAttributeBuilder(constructorInfo, ctorArgs,
propertyInfoList.ToArray(), propertyArgs.ToArray(),
fieldInfoList.ToArray(), fieldArgs.ToArray());
}
internal static Attribute GetAttribute(AttributeAst attributeAst)
{
Attribute attribute;
int count = attributeAst.PositionalArguments.Count;
IEnumerable<string> source = from name in attributeAst.NamedArguments select name.ArgumentName;
int argCount = count + source.Count<string>();
CallInfo callInfo = new CallInfo(argCount, source);
object[] args = new object[argCount + 1];
Type reflectionAttributeType = attributeAst.TypeName.GetReflectionAttributeType();
if (reflectionAttributeType == null)
{
throw InterpreterError.NewInterpreterException(attributeAst, typeof(RuntimeException), attributeAst.Extent, "CustomAttributeTypeNotFound", ParserStrings.CustomAttributeTypeNotFound, new object[] { attributeAst.TypeName.FullName });
}
args[0] = reflectionAttributeType;
ConstantValueVisitor visitor = new ConstantValueVisitor {
AttributeArgument = true
};
int num3 = 1;
foreach (ExpressionAst ast in attributeAst.PositionalArguments)
{
args[num3++] = ast.Accept(visitor);
}
foreach (NamedAttributeArgumentAst ast2 in attributeAst.NamedArguments)
{
args[num3++] = ast2.Argument.Accept(visitor);
}
try
{
attribute = (Attribute) GetAttributeGenerator(callInfo).DynamicInvoke(args);
}
catch (TargetInvocationException exception)
{
Exception innerException = exception.InnerException;
RuntimeException exception3 = innerException as RuntimeException;
if (exception3 == null)
{
exception3 = InterpreterError.NewInterpreterExceptionWithInnerException(null, typeof(RuntimeException), attributeAst.Extent, "ExceptionConstructingAttribute", ExtendedTypeSystem.ExceptionConstructingAttribute, innerException, new object[] { innerException.Message, attributeAst.TypeName.FullName });
}
InterpreterError.UpdateExceptionErrorRecordPosition(exception3, attributeAst.Extent);
throw exception3;
}
return attribute;
}
private Action<List<Expression>, Expression> GetSwitchBodyGenerator(SwitchStatementAst switchStatementAst, AutomaticVarSaver avs, ParameterExpression skipDefault)
{
return delegate (List<Expression> exprs, Expression newValue) {
PSSwitchClauseEvalBinder binder = PSSwitchClauseEvalBinder.Get(switchStatementAst.Flags);
exprs.Add(avs.SetNewValue(newValue));
if (skipDefault != null)
{
exprs.Add(Expression.Assign(skipDefault, ExpressionCache.Constant(false)));
}
IsConstantValueVisitor visitor = new IsConstantValueVisitor();
ConstantValueVisitor visitor2 = new ConstantValueVisitor();
int count = switchStatementAst.Clauses.Count;
for (int j = 0; j < count; j++)
{
Expression expression;
Tuple<ExpressionAst, StatementBlockAst> tuple = switchStatementAst.Clauses[j];
object obj2 = ((bool) tuple.Item1.Accept(visitor)) ? tuple.Item1.Accept(visitor2) : null;
if (obj2 is ScriptBlock)
{
MethodCallExpression expression2 = Expression.Call(Expression.Constant(obj2), CachedReflectionInfo.ScriptBlock_DoInvokeReturnAsIs, new Expression[] { ExpressionCache.Constant(true), Expression.Constant(ScriptBlock.ErrorHandlingBehavior.WriteToExternalErrorPipe), this.GetLocal(0).Convert(typeof(object)), ExpressionCache.AutomationNullConstant, ExpressionCache.AutomationNullConstant, ExpressionCache.NullObjectArray });
expression = Expression.Dynamic(PSConvertBinder.Get(typeof(bool)), typeof(bool), expression2);
}
else if (obj2 != null)
{
SwitchFlags flags = switchStatementAst.Flags;
Expression expression3 = Expression.Constant(((obj2 is Regex) || (obj2 is WildcardPattern)) ? obj2 : obj2.ToString());
Expression expression4 = Expression.Dynamic(PSToStringBinder.Get(), typeof(string), this.GetLocal(0), _executionContextParameter);
if (((flags & SwitchFlags.Regex) != SwitchFlags.None) || (obj2 is Regex))
{
expression = Expression.Call(CachedReflectionInfo.SwitchOps_ConditionSatisfiedRegex, ExpressionCache.Constant((flags & SwitchFlags.CaseSensitive) != SwitchFlags.None), expression3, Expression.Constant(tuple.Item1.Extent), expression4, _executionContextParameter);
}
else if (((flags & SwitchFlags.Wildcard) != SwitchFlags.None) || (obj2 is WildcardPattern))
{
expression = Expression.Call(CachedReflectionInfo.SwitchOps_ConditionSatisfiedWildcard, ExpressionCache.Constant((flags & SwitchFlags.CaseSensitive) != SwitchFlags.None), expression3, expression4, _executionContextParameter);
}
else
{
expression = CallStringEquals(expression3, expression4, (flags & SwitchFlags.CaseSensitive) == SwitchFlags.None);
}
}
else
{
Expression expression5 = this.Compile(tuple.Item1);
expression = Expression.Dynamic(binder, typeof(bool), expression5, this.GetLocal(0), _executionContextParameter);
}
exprs.Add(this.UpdatePosition(tuple.Item1));
if (skipDefault != null)
{
exprs.Add(Expression.IfThen(expression, Expression.Block(this.Compile(tuple.Item2), Expression.Assign(skipDefault, ExpressionCache.Constant(true)))));
}
else
{
exprs.Add(Expression.IfThen(expression, this.Compile(tuple.Item2)));
}
}
if (skipDefault != null)
{
exprs.Add(Expression.IfThen(Expression.Not(skipDefault), this.Compile(switchStatementAst.Default)));
}
};
}