protected internal override Node VisitVariableTarget(VariableTarget node)
{
node = (VariableTarget)base.VisitVariableTarget(node);
this.data.SetFactoryExpression(node, Evaluator.CreateDataTarget(Expression.Convert(this.data.ConvertToLinqExpression(new VariableSqlExpression(node.Variable)), typeof(IDataTarget))));
return(node);
}
protected internal override Node VisitVariableTarget(VariableTarget node)
{
node = this.ValidateChildren(node);
var variableType = this.Scope.GetVariableType(node.Variable);
if (variableType == null)
{
this.AddError(node, $"Undeclared variable '{node.Variable}'.");
}
else if (!variableType.Interfaces.Contains(typeof(IDataTarget)))
{
this.AddError(node, $"Variable {node.Variable} is not a data target.");
}
this.Data.SetType(node, variableType);
this.Data.SetScope(node, NodeScope.Constant);
return(node);
}
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 (String.Equals(paramAst.TypeName.FullName, "switch", StringComparison.OrdinalIgnoreCase))
{
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);
}
}
}
/// <summary>
/// Visits a <see cref="VariableTarget"/>.
/// </summary>
/// <param name="node">
/// The node.
/// </param>
/// <returns>
/// The node, or a new version of the node.
/// </returns>
protected internal virtual Node VisitVariableTarget([NotNull] VariableTarget node)
{
return(node.VisitChildren(this));
}
/// <summary>
/// Visits a <see cref="VariableTarget"/>.
/// </summary>
/// <param name="node">
/// The node.
/// </param>
/// <returns>
/// The node, or a new version of the node.
/// </returns>
protected internal override Node VisitVariableTarget(VariableTarget node)
{
return(this.VisitImplementation(node) ?? base.VisitVariableTarget(node));
}
