public AssignmentTarget(AssignmentStatementAst ast)
{
this._targetAst = ast.Left;
this._rightAst = ast.Right;
if (_rightAst != null)
{
Constant = Undetermined.UndeterminedConstant;
Type = typeof(Undetermined);
}
CommandExpressionAst cmExAst = _rightAst as CommandExpressionAst;
if (cmExAst != null)
{
ExpressionAst exprAst = cmExAst.Expression;
Type = exprAst.StaticType;
if (exprAst is ConvertExpressionAst)
{
ConvertExpressionAst convertAst = exprAst as ConvertExpressionAst;
Type = DeepestRelatedDerivedClass(convertAst.StaticType, Type);
if (convertAst.Child is ConstantExpressionAst)
{
Constant = (convertAst.Child as ConstantExpressionAst).Value;
}
}
else if (exprAst is BinaryExpressionAst)
{
BinaryExpressionAst binAst = exprAst as BinaryExpressionAst;
if (binAst != null && binAst.Operator == TokenKind.As && binAst.Right is TypeExpressionAst)
{
Type = DeepestRelatedDerivedClass((binAst.Right as TypeExpressionAst).TypeName.GetReflectionType(),
binAst.Left.StaticType);
if (binAst.Left is ConstantExpressionAst)
{
Constant = (binAst.Left as ConstantExpressionAst).Value;
}
else if (binAst.Left is VariableExpressionAst)
{
_rightHandSideVariable = new VariableTarget(binAst.Left as VariableExpressionAst);
}
}
}
else if (exprAst is ConstantExpressionAst)
{
Constant = (cmExAst.Expression as ConstantExpressionAst).Value;
}
else if (exprAst is VariableExpressionAst)
{
_rightHandSideVariable = new VariableTarget(cmExAst.Expression as VariableExpressionAst);
if (String.Equals((exprAst as VariableExpressionAst).VariablePath.UserPath, "this", StringComparison.OrdinalIgnoreCase))
{
Constant = SpecialVars.ThisVariable;
}
}
//Store the type info for variable assignment from .Net type
else if (exprAst is MemberExpressionAst)
{
Type = DeepestRelatedDerivedClass(Type, GetTypeFromMemberExpressionAst(exprAst as MemberExpressionAst));
}
}
// We'll consider case where there is only 1 pipeline element for now
else if (_rightAst is PipelineAst && (_rightAst as PipelineAst).PipelineElements.Count == 1)
{
#region Process New-Object command
CommandAst cmdAst = (_rightAst as PipelineAst).PipelineElements[0] as CommandAst;
if (cmdAst != null && cmdAst.CommandElements.Count > 1)
{
StringConstantExpressionAst stringAst = cmdAst.CommandElements[0] as StringConstantExpressionAst;
if (stringAst != null && String.Equals(stringAst.Value, "new-object", StringComparison.OrdinalIgnoreCase))
{
CommandParameterAst secondElement = cmdAst.CommandElements[1] as CommandParameterAst;
StringConstantExpressionAst typeName = null;
if (secondElement != null)
{
if (String.Equals(secondElement.ParameterName, "TypeName", StringComparison.OrdinalIgnoreCase))
{
if (secondElement.Argument != null)
{
typeName = secondElement.Argument as StringConstantExpressionAst;
}
else
{
if (cmdAst.CommandElements.Count > 2)
{
typeName = cmdAst.CommandElements[2] as StringConstantExpressionAst;
}
}
}
}
else
{
typeName = cmdAst.CommandElements[1] as StringConstantExpressionAst;
}
if (typeName != null)
{
Type = System.Type.GetType(typeName.Value) ?? typeof(object);
}
}
}
#endregion
}
SetVariableName();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="VarName"></param>
/// <param name="block"></param>
internal Phi(String VarName, Block block)
{
Name = VarName;
Operands = new VariableTarget[block._predecessors.Count()];
for (int i = 0; i < Operands.Length; i += 1)
{
Operands[i] = new VariableTarget();
}
RealName = Name;
DefinedBlock = block;
}
private void ProcessParameters(IEnumerable<ParameterAst> parameters)
{
foreach (var parameter in parameters)
{
var variablePath = parameter.Name.VariablePath;
bool isSwitchOrMandatory = false;
Type type = null;
foreach (var paramAst in parameter.Attributes)
{
if (paramAst is TypeConstraintAst)
{
if (type == null)
{
type = paramAst.TypeName.GetReflectionType();
}
if (paramAst.TypeName.GetReflectionType() == typeof(System.Management.Automation.SwitchParameter))
{
isSwitchOrMandatory = true;
}
}
else if (paramAst is AttributeAst)
{
var args = (paramAst as AttributeAst).NamedArguments;
if (args != null)
{
foreach (NamedAttributeArgumentAst arg in args)
{
if (String.Equals(arg.ArgumentName, "mandatory", StringComparison.OrdinalIgnoreCase)
&& String.Equals(arg.Argument.Extent.Text, "$true", StringComparison.OrdinalIgnoreCase))
{
isSwitchOrMandatory = true;
}
}
}
}
}
var varName = AssignmentTarget.GetUnaliasedVariableName(variablePath);
var details = _variables[varName];
details.Type = type ?? details.Type ?? typeof(object);
if (parameter.DefaultValue != null)
{
var assignTarget = new AssignmentTarget(varName, type);
if (parameter.DefaultValue is ConstantExpressionAst)
{
assignTarget.Constant = (parameter.DefaultValue as ConstantExpressionAst).Value;
assignTarget.Type = assignTarget.Constant == null ? typeof(object) : assignTarget.Constant.GetType();
}
Entry.AddAst(assignTarget);
}
else if (isSwitchOrMandatory)
{
// Consider switch or mandatory parameter as already initialized
Entry.AddAst(new AssignmentTarget(varName, type));
}
else
{
VariableTarget varTarget = new VariableTarget(parameter.Name);
varTarget.Type = details.Type;
Entry.AddAst(varTarget);
}
}
}
