private void CheckLHSAssign(ExpressionAst lhs, BitArray assignedBitArray)
{
ConvertExpressionAst ast = lhs as ConvertExpressionAst;
Type convertType = null;
if (ast != null)
{
lhs = ast.Child;
convertType = ast.StaticType;
}
VariableExpressionAst item = lhs as VariableExpressionAst;
VariablePath variablePath = item.VariablePath;
if (variablePath.IsAnyLocal())
{
string unaliasedVariableName = GetUnaliasedVariableName(variablePath);
if ((convertType == null) && (unaliasedVariableName.Equals("foreach", StringComparison.OrdinalIgnoreCase) || unaliasedVariableName.Equals("switch", StringComparison.OrdinalIgnoreCase)))
{
convertType = typeof(object);
}
VariableAnalysisDetails details = this.CheckLHSAssignVar(unaliasedVariableName, assignedBitArray, convertType);
details.AssociatedAsts.Add(item);
item.TupleIndex = details.LocalTupleIndex;
item.Automatic = details.Automatic;
}
else
{
item.TupleIndex = -2;
}
}
private void VisitParameters(ReadOnlyCollection <ParameterAst> parameters)
{
foreach (ParameterAst ast in parameters)
{
VariablePath variablePath = ast.Name.VariablePath;
if (variablePath.IsAnyLocal())
{
VariableAnalysisDetails details;
string unaliasedVariableName = VariableAnalysis.GetUnaliasedVariableName(variablePath);
if (this._variables.TryGetValue(unaliasedVariableName, out details))
{
object obj2;
details.Type = ast.StaticType;
if (!Compiler.TryGetDefaultParameterValue(ast.StaticType, out obj2))
{
details.LocalTupleIndex = -2;
}
}
else
{
this.NoteVariable(unaliasedVariableName, -1, ast.StaticType, false, false);
}
}
}
}
private void AnalyzeBlock(BitArray assignedBitArray, Block block)
{
foreach (Ast ast in block._asts)
{
VariableExpressionAst ast2 = ast as VariableExpressionAst;
if (ast2 != null)
{
VariablePath variablePath = ast2.VariablePath;
if (variablePath.IsAnyLocal())
{
string unaliasedVariableName = GetUnaliasedVariableName(variablePath);
VariableAnalysisDetails details = this._variables[unaliasedVariableName];
if (details.Automatic)
{
ast2.TupleIndex = details.LocalTupleIndex;
ast2.Automatic = true;
}
else
{
ast2.TupleIndex = (assignedBitArray[details.BitIndex] && !details.PreferenceVariable) ? details.LocalTupleIndex : -2;
}
}
}
else
{
AssignmentTarget target = ast as AssignmentTarget;
if (target != null)
{
if (target._targetAst != null)
{
this.CheckLHSAssign(target._targetAst, assignedBitArray);
}
else
{
this.CheckLHSAssignVar(target._variableName, assignedBitArray, target._type);
}
}
else
{
DataStatementAst item = ast as DataStatementAst;
if (item != null)
{
VariableAnalysisDetails details2 = this.CheckLHSAssignVar(item.Variable, assignedBitArray, typeof(object));
item.TupleIndex = details2.LocalTupleIndex;
details2.AssociatedAsts.Add(item);
}
}
}
}
}
public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
VariablePath variablePath = variableExpressionAst.VariablePath;
if (variablePath.IsAnyLocal())
{
if (variablePath.IsPrivate)
{
this._disableOptimizations = true;
}
this.NoteVariable(VariableAnalysis.GetUnaliasedVariableName(variablePath), -1, null, false, false);
}
return(AstVisitAction.Continue);
}
private Tuple <Type, Dictionary <string, int> > AnalyzeImpl(IParameterMetadataProvider ast, bool disableOptimizations, bool scriptCmdlet)
{
this._variables = FindAllVariablesVisitor.Visit(ast, disableOptimizations, scriptCmdlet, out this._localsAllocated, out this._disableOptimizations);
this.Init();
if (ast.Parameters != null)
{
foreach (ParameterAst ast2 in ast.Parameters)
{
VariablePath variablePath = ast2.Name.VariablePath;
if (variablePath.IsAnyLocal())
{
bool flag = false;
int num = -1;
Type c = null;
foreach (AttributeBaseAst ast3 in ast2.Attributes)
{
if (ast3 is TypeConstraintAst)
{
num++;
if (c == null)
{
c = ast3.TypeName.GetReflectionType();
}
}
else
{
Type reflectionAttributeType = ast3.TypeName.GetReflectionAttributeType();
if (typeof(ValidateArgumentsAttribute).IsAssignableFrom(reflectionAttributeType) || typeof(ArgumentTransformationAttribute).IsAssignableFrom(reflectionAttributeType))
{
flag = true;
}
}
}
string unaliasedVariableName = GetUnaliasedVariableName(variablePath);
VariableAnalysisDetails details = this._variables[unaliasedVariableName];
c = c ?? (details.Type ?? typeof(object));
if (((flag || (num > 0)) || (typeof(PSReference).IsAssignableFrom(c) || MustBeBoxed(c))) && (!details.Automatic && !details.PreferenceVariable))
{
details.LocalTupleIndex = -2;
}
this._entryBlock.AddAst(new AssignmentTarget(unaliasedVariableName, c));
}
}
}
ast.Body.Accept(this);
return(this.FinishAnalysis(scriptCmdlet));
}
public object VisitAssignmentStatement(AssignmentStatementAst assignmentStatementAst)
{
assignmentStatementAst.Right.Accept(this);
foreach (ExpressionAst ast in GetAssignmentTargets(assignmentStatementAst.Left))
{
bool flag = false;
int num = 0;
ExpressionAst child = ast;
while (child is AttributedExpressionAst)
{
num++;
if (!(child is ConvertExpressionAst))
{
flag = true;
}
child = ((AttributedExpressionAst)child).Child;
}
if (child is VariableExpressionAst)
{
if (flag || (num > 1))
{
VariablePath variablePath = ((VariableExpressionAst)child).VariablePath;
if (variablePath.IsAnyLocal())
{
VariableAnalysisDetails details = this._variables[GetUnaliasedVariableName(variablePath)];
details.LocalTupleIndex = -2;
}
}
else
{
this._currentBlock.AddAst(new AssignmentTarget(ast));
}
}
else
{
ast.Accept(this);
}
}
return(null);
}
public object VisitVariableExpression(VariableExpressionAst variableExpressionAst)
{
VariablePath variablePath = variableExpressionAst.VariablePath;
if (variablePath.IsAnyLocal())
{
VariableAnalysisDetails details = this._variables[GetUnaliasedVariableName(variablePath)];
if (details.LocalTupleIndex != -1)
{
variableExpressionAst.TupleIndex = details.PreferenceVariable ? -2 : details.LocalTupleIndex;
variableExpressionAst.Automatic = details.Automatic;
}
else
{
this._currentBlock.AddAst(variableExpressionAst);
}
details.AssociatedAsts.Add(variableExpressionAst);
}
else
{
variableExpressionAst.TupleIndex = -2;
}
return(null);
}
