protected override IEnumerable<IAstElement> VisitOrTransformChildren(AstElementTransform transform)
{
if (this.Target != null)
yield return this.Target = transform(this.Target);
yield return this.Reference = (IAstPropertyReference)transform(this.Reference);
}
public ObjectInitializerEntry(string name, IAstElement value)
{
Argument.RequireNotNull("value", value);
this.Name = name;
this.Value = value;
}
public string Transform(IAstElement element)
{
var builder = new StringBuilder();
this.Append(builder, element);
return(builder.ToString());
}
public ObjectInitializerEntry(string name, IAstElement value)
{
Argument.RequireNotNull("value", value);
this.Name = name;
this.Value = value;
}
protected override IEnumerable<IAstElement> VisitOrTransformChildren(AstElementTransform transform)
{
yield return this.Target = transform(this.Target);
foreach (var argument in this.Arguments.Transform(transform)) {
yield return argument;
}
}
public ParsingResult(IAstElement root, IEnumerable<ParsingMessage> messages)
{
this.Root = root;
this.Messages = new ReadOnlyCollection<ParsingMessage>(
(messages as IList<ParsingMessage>) ?? messages.ToList()
);
}
public ParsingResult(IAstElement root, IEnumerable <ParsingMessage> messages)
{
this.Root = root;
this.Messages = new ReadOnlyCollection <ParsingMessage>(
(messages as IList <ParsingMessage>) ?? messages.ToList()
);
}
private IAstTypeReference GetTypeFromUsage(IAstElement parent, AstParameterReference parameter)
{
if (parent is AstReturnStatement || parent is AstLambdaExpression)
{
return(null);
}
var binary = parent as BinaryExpression;
if (binary != null)
{
var argumentIndex = binary.Left == parameter ? 0 : 1;
return(binary.Operator.ParameterTypes.ElementAt(argumentIndex));
}
var call = parent as CallExpression;
if (call != null)
{
var argumentIndex = call.Arguments.IndexOf(parameter);
return(call.Callee.ParameterTypes.ElementAt(argumentIndex));
}
throw new NotImplementedException("InferParameterTypes: Can not collect parameter type from usage in " + parent);
}
public AstFunctionReferenceExpression(IAstElement target, IAstMethodReference reference)
{
this.Target = target;
this.Reference = reference;
SetExpressionType(() => AstUnknownType.WithNoName);
}
private void CompileCil(ILProcessor body, IAstElement element, CilCompilationContext context)
{
var compiler = this.cilCompilers.SingleOrDefault(c => c.CanCompile(body, element));
if (compiler == null)
throw new NotImplementedException("LightCompiler: No CilCompiler for " + element);
compiler.Compile(body, element, context);
}
public MemberExpression(IAstElement target, string name)
{
Argument.RequireNotNull("target", target);
Argument.RequireNotNullAndNotEmpty("name", name);
this.Target = target;
this.Name = name;
}
public MemberExpression(IAstElement target, string name)
{
Argument.RequireNotNull("target", target);
Argument.RequireNotNullAndNotEmpty("name", name);
this.Target = target;
this.Name = name;
}
public IndexerExpression(IAstElement target, IEnumerable<IAstElement> arguments)
{
var argumentList = arguments.ToList();
Argument.RequireNotNullAndNotContainsNull("arguments", argumentList);
this.Target = target;
this.Arguments = argumentList;
}
protected override IEnumerable <IAstElement> VisitOrTransformChildren(AstElementTransform transform)
{
yield return(this.Condition = transform(this.Condition));
foreach (var element in this.Body.Transform(transform))
{
yield return(element);
}
}
public IfOrUnlessStatement(IfOrUnlessKind kind, IAstElement condition, IEnumerable<IAstElement> body)
{
var bodyList = body.ToList();
Argument.RequireNotNullNotEmptyAndNotContainsNull("body", bodyList);
this.Kind = kind;
this.Condition = condition;
this.Body = bodyList;
}
public static void TransformDescendants(this IAstElement ancestor, AstElementTransform transform)
{
Argument.RequireNotNull("transform", transform);
ancestor.TransformChildren(c => {
c.TransformDescendants(transform);
return(transform(c));
});
}
public IAstElement Process(IAstElement element, ISet<ProcessingStage> stages)
{
var context = new ProcessingContext();
foreach (var source in topLevelNameSources) {
context.Scope.Add(source);
}
var steps = this.steps.Where(s => stages.Contains(s.Stage)).ToArray();
return Process(element, context, steps);
}
public AstNewExpression(IAstTypeReference type, IEnumerable<IAstExpression> arguments, IAstElement initializer)
{
var argumentList = arguments.ToList();
Argument.RequireNotNullAndNotContainsNull("arguments", argumentList);
this.Type = type;
this.Arguments = argumentList;
this.Initializer = initializer;
}
public IndexerExpression(IAstElement target, IEnumerable <IAstElement> arguments)
{
var argumentList = arguments.ToList();
Argument.RequireNotNullAndNotContainsNull("arguments", argumentList);
this.Target = target;
this.Arguments = argumentList;
}
public AstFunctionReferenceExpression(IAstElement target, IAstMethodReference reference)
{
this.Target = target;
this.Function = reference;
this.ExpressionType = new AstInferredFunctionType(
() => this.Function.ParameterTypes,
() => this.Function.ReturnType
);
}
public AstFunctionReferenceExpression(IAstElement target, IAstMethodReference reference)
{
this.Target = target;
this.Function = reference;
this.ExpressionType = new AstInferredFunctionType(
() => this.Function.ParameterTypes,
() => this.Function.ReturnType
);
}
public AstLambdaExpression(IEnumerable<AstParameterDefinition> parameters, IAstElement body)
{
var parametersList = parameters.ToList();
Argument.RequireNotNullAndNotContainsNull("parameters", parametersList);
Parameters = parametersList;
Body = body;
ExpressionType = AstUnknownType.WithNoName;
}
public AstNewExpression(IAstTypeReference type, IEnumerable <IAstExpression> arguments, IAstElement initializer)
{
var argumentList = arguments.ToList();
Argument.RequireNotNullAndNotContainsNull("arguments", argumentList);
this.Type = type;
this.Arguments = argumentList;
this.Initializer = initializer;
}
public IfOrUnlessStatement(IfOrUnlessKind kind, IAstElement condition, IEnumerable <IAstElement> body)
{
var bodyList = body.ToList();
Argument.RequireNotNullNotEmptyAndNotContainsNull("body", bodyList);
this.Kind = kind;
this.Condition = condition;
this.Body = bodyList;
}
IAstElement IProcessingStep.ProcessAfterChildren(IAstElement element, ProcessingContext context)
{
var matched = element as TAstElement;
if (matched == null)
{
return(element);
}
return(this.ProcessAfterChildren(matched, context));
}
public static void TransformChildren(this IAstElement parent, AstElementTransform transform)
{
Argument.RequireNotNull("parent", parent);
Argument.RequireNotNull("transform", transform);
var enumerator = parent.VisitOrTransformChildren(transform).GetEnumerator();
while (enumerator.MoveNext())
{
}
}
private void CompileCil(ILProcessor body, IAstElement element, CilCompilationContext context)
{
var compiler = this.cilCompilers.SingleOrDefault(c => c.CanCompile(body, element));
if (compiler == null)
{
throw new NotImplementedException("LightCompiler: No CilCompiler for " + element);
}
compiler.Compile(body, element, context);
}
public IAstElement Process(IAstElement element, ProcessingOptions options = null)
{
options = options ?? new ProcessingOptions();
var context = new ProcessingContext(options);
foreach (var source in topLevelNameSources) {
context.Scope.Add(source);
}
var steps = this.allSteps.Where(s => options.Stages.Contains(s.Stage)).ToArray();
return Process(element, context, steps);
}
public AstLambdaExpression(IEnumerable<AstParameterDefinition> parameters, IAstElement body)
{
var parametersList = parameters.ToList();
Argument.RequireNotNullAndNotContainsNull("parameters", parametersList);
Parameters = parametersList;
Body = body;
ExpressionType = new AstInferredFunctionType(
() => this.Parameters.Select(p => p.Type),
() => this.ReturnType
);
}
public AstLambdaExpression(IEnumerable <AstParameterDefinition> parameters, IAstElement body)
{
var parametersList = parameters.ToList();
Argument.RequireNotNullAndNotContainsNull("parameters", parametersList);
Parameters = parametersList;
Body = body;
ExpressionType = new AstInferredFunctionType(
() => this.Parameters.Select(p => p.Type),
() => this.ReturnType
);
}
public static void TransformChildren <TAstElement>(this IAstElement parent, AstElementTransform <TAstElement> transform)
where TAstElement : IAstElement
{
Argument.RequireNotNull("transform", transform);
parent.TransformChildren(c => {
if (!(c is TAstElement))
{
return(c);
}
return(transform((TAstElement)c));
});
}
public static IEnumerable <IAstElement> Descendants(this IAstElement ancestor)
{
Argument.RequireNotNull("ancestor", ancestor);
foreach (var child in ancestor.Children())
{
yield return(child);
foreach (var descendant in child.Descendants())
{
yield return(descendant);
}
}
}
public IAstElement Process(IAstElement element, ProcessingOptions options = null)
{
options = options ?? new ProcessingOptions();
var context = new ProcessingContext(options);
foreach (var source in topLevelNameSources)
{
context.Scope.Add(source);
}
var steps = this.allSteps.Where(s => options.Stages.Contains(s.Stage)).ToArray();
return(Process(element, context, steps));
}
public static void TransformDescendants <TAstElement>(this IAstElement ancestor, AstElementTransform <TAstElement> transform)
where TAstElement : IAstElement
{
Argument.RequireNotNull("transform", transform);
ancestor.TransformDescendants(c => {
c.TransformDescendants(transform);
if (!(c is TAstElement))
{
return(c);
}
return(transform((TAstElement)c));
});
}
public IAstMethodReference ResolveMethodGroup(AstMethodGroup group, IAstElement target, IList<IAstExpression> arguments)
{
var candidates = GetCandidates(group, target, arguments)
.GroupBy(c => c.Item2)
.OrderBy(g => g.Key)
.First()
.ToArray();
if (candidates.Length > 1)
throw new NotImplementedException(string.Format("OverloadResolver: Ambiguous best match found for {0}: {1}.", @group.Name, string.Join(", ", candidates.AsEnumerable())));
if (candidates.Length == 0)
throw new NotImplementedException("OverloadResolver: No match found for " + @group.Name);
return candidates[0].Item1;
}
// ReSharper disable LoopCanBeConvertedToQuery
private IAstElement Process(IAstElement element, ProcessingContext context, IProcessingStep[] steps)
{
foreach (var step in steps) {
element = step.ProcessBeforeChildren(element, context);
}
context.ElementStack.Push(element);
element.TransformChildren(c => Process(c, context, steps));
context.ElementStack.Pop();
foreach (var step in steps) {
element = step.ProcessAfterChildren(element, context);
}
return element;
}
// ReSharper disable LoopCanBeConvertedToQuery
private IAstElement Process(IAstElement element, ProcessingContext context, IProcessingStep[] steps)
{
foreach (var step in steps)
{
element = step.ProcessBeforeChildren(element, context);
}
context.ElementStack.Push(element);
element.TransformChildren(c => Process(c, context, steps));
context.ElementStack.Pop();
foreach (var step in steps)
{
element = step.ProcessAfterChildren(element, context);
}
return(element);
}
private IEnumerable<Tuple<IAstMethodReference, int>> GetCandidates(AstMethodGroup @group, IAstElement target, IList<IAstExpression> arguments)
{
// little bit of cheating for now
foreach (var method in @group.Methods) {
var reflected = method as AstReflectedMethod;
if (reflected == null)
throw new NotImplementedException("OverloadResolver: Reference type " + method.GetType() + " is not yet supported.");
var parameterTypes = reflected.Method.GetParameters().Select(p => p.ParameterType);
var argumentTypes = arguments.Select(a => ((AstReflectedType)a.ExpressionType).ActualType);
if (method.Location == MethodLocation.Extension)
argumentTypes = new[] {((AstReflectedType)((IAstExpression)target).ExpressionType).ActualType}.Concat(argumentTypes);
var match = GetOrMakeMatch(reflected, parameterTypes, argumentTypes);
if (match != null)
yield return match;
}
}
private void CollectTypesFromUsages(IAstElement parent, AstParameterDefinition parameter, ISet <IAstTypeReference> collectedTypes)
{
foreach (var child in parent.Children())
{
var reference = child as AstParameterReference;
if (reference != null && reference.Parameter == parameter)
{
var type = GetTypeFromUsage(parent, reference);
if (type != null)
{
collectedTypes.Add(type);
}
continue;
}
CollectTypesFromUsages(child, parameter, collectedTypes);
}
}
public override void Visit(IAstElement o)
{
}
bool ICilCompiler.CanCompile(ILProcessor processor, IAstElement element)
{
return(element is TAstElement);
}
void ICilCompiler.Compile(ILProcessor processor, IAstElement element, CilCompilationContext context)
{
this.Compile(processor, (TAstElement)element, context);
}
protected void Append(StringBuilder builder, IAstElement element)
{
var assignmentStatement = element as AssignmentStatement;
if (assignmentStatement != null) {
AppendAssignmentStatement(builder, assignmentStatement);
return;
}
var baseConstructorCall = element as AstBaseConstructorCall;
if (baseConstructorCall != null) {
AppendBaseConstructorCall(builder, baseConstructorCall);
return;
}
var builtInOperator = element as AstBuiltInOperator;
if (builtInOperator != null) {
AppendBuiltInOperator(builder, builtInOperator);
return;
}
var definedConstructor = element as AstDefinedConstructor;
if (definedConstructor != null) {
AppendDefinedConstructor(builder, definedConstructor);
return;
}
var definedMethod = element as AstDefinedMethod;
if (definedMethod != null) {
AppendDefinedMethod(builder, definedMethod);
return;
}
var definedProperty = element as AstDefinedProperty;
if (definedProperty != null) {
AppendDefinedProperty(builder, definedProperty);
return;
}
var definedType = element as AstDefinedType;
if (definedType != null) {
AppendDefinedType(builder, definedType);
return;
}
var functionReferenceExpression = element as AstFunctionReferenceExpression;
if (functionReferenceExpression != null) {
AppendFunctionReferenceExpression(builder, functionReferenceExpression);
return;
}
var implicitType = element as AstImplicitType;
if (implicitType != null) {
AppendImplicitType(builder, implicitType);
return;
}
var lambdaExpression = element as AstLambdaExpression;
if (lambdaExpression != null) {
AppendLambdaExpression(builder, lambdaExpression);
return;
}
var listInitializer = element as AstListInitializer;
if (listInitializer != null) {
AppendListInitializer(builder, listInitializer);
return;
}
var methodGroup = element as AstMethodGroup;
if (methodGroup != null) {
AppendMethodGroup(builder, methodGroup);
return;
}
var missingMethod = element as AstMissingMethod;
if (missingMethod != null) {
AppendMissingMethod(builder, missingMethod);
return;
}
var newExpression = element as AstNewExpression;
if (newExpression != null) {
AppendNewExpression(builder, newExpression);
return;
}
var parameterDefinition = element as AstParameterDefinition;
if (parameterDefinition != null) {
AppendParameterDefinition(builder, parameterDefinition);
return;
}
var parameterReference = element as AstParameterReference;
if (parameterReference != null) {
AppendParameterReference(builder, parameterReference);
return;
}
var propertyDefinition = element as AstPropertyDefinition;
if (propertyDefinition != null) {
AppendPropertyDefinition(builder, propertyDefinition);
return;
}
var propertyExpression = element as AstPropertyExpression;
if (propertyExpression != null) {
AppendPropertyExpression(builder, propertyExpression);
return;
}
var reflectedConstructor = element as AstReflectedConstructor;
if (reflectedConstructor != null) {
AppendReflectedConstructor(builder, reflectedConstructor);
return;
}
var reflectedMethod = element as AstReflectedMethod;
if (reflectedMethod != null) {
AppendReflectedMethod(builder, reflectedMethod);
return;
}
var reflectedProperty = element as AstReflectedProperty;
if (reflectedProperty != null) {
AppendReflectedProperty(builder, reflectedProperty);
return;
}
var reflectedType = element as AstReflectedType;
if (reflectedType != null) {
AppendReflectedType(builder, reflectedType);
return;
}
var returnStatement = element as AstReturnStatement;
if (returnStatement != null) {
AppendReturnStatement(builder, returnStatement);
return;
}
var root = element as AstRoot;
if (root != null) {
AppendRoot(builder, root);
return;
}
var thisExpression = element as AstThisExpression;
if (thisExpression != null) {
AppendThisExpression(builder, thisExpression);
return;
}
var typeDefinition = element as AstTypeDefinition;
if (typeDefinition != null) {
AppendTypeDefinition(builder, typeDefinition);
return;
}
var unknownMethod = element as AstUnknownMethod;
if (unknownMethod != null) {
AppendUnknownMethod(builder, unknownMethod);
return;
}
var unknownType = element as AstUnknownType;
if (unknownType != null) {
AppendUnknownType(builder, unknownType);
return;
}
var variableDefinition = element as AstVariableDefinition;
if (variableDefinition != null) {
AppendVariableDefinition(builder, variableDefinition);
return;
}
var variableReference = element as AstVariableReference;
if (variableReference != null) {
AppendVariableReference(builder, variableReference);
return;
}
var voidType = element as AstVoidType;
if (voidType != null) {
AppendVoidType(builder, voidType);
return;
}
var binaryExpression = element as BinaryExpression;
if (binaryExpression != null) {
AppendBinaryExpression(builder, binaryExpression);
return;
}
var callExpression = element as CallExpression;
if (callExpression != null) {
AppendCallExpression(builder, callExpression);
return;
}
var continueStatement = element as ContinueStatement;
if (continueStatement != null) {
AppendContinueStatement(builder, continueStatement);
return;
}
var forStatement = element as ForStatement;
if (forStatement != null) {
AppendForStatement(builder, forStatement);
return;
}
var identifierExpression = element as IdentifierExpression;
if (identifierExpression != null) {
AppendIdentifierExpression(builder, identifierExpression);
return;
}
var ifOrUnlessStatement = element as IfOrUnlessStatement;
if (ifOrUnlessStatement != null) {
AppendIfOrUnlessStatement(builder, ifOrUnlessStatement);
return;
}
var importDefinition = element as ImportDefinition;
if (importDefinition != null) {
AppendImportDefinition(builder, importDefinition);
return;
}
var indexerExpression = element as IndexerExpression;
if (indexerExpression != null) {
AppendIndexerExpression(builder, indexerExpression);
return;
}
var memberExpression = element as MemberExpression;
if (memberExpression != null) {
AppendMemberExpression(builder, memberExpression);
return;
}
var objectInitializer = element as ObjectInitializer;
if (objectInitializer != null) {
AppendObjectInitializer(builder, objectInitializer);
return;
}
var objectInitializerEntry = element as ObjectInitializerEntry;
if (objectInitializerEntry != null) {
AppendObjectInitializerEntry(builder, objectInitializerEntry);
return;
}
var primitiveValue = element as PrimitiveValue;
if (primitiveValue != null) {
AppendPrimitiveValue(builder, primitiveValue);
return;
}
var stringWithInterpolation = element as StringWithInterpolation;
if (stringWithInterpolation != null) {
AppendStringWithInterpolation(builder, stringWithInterpolation);
return;
}
builder.Append(element);
}
public ForStatement(string variableName, IAstElement source, IEnumerable<IAstStatement> body)
{
VariableName = variableName;
Source = source;
Body = body.ToList();
}
private IAstMethodReference InnerResolve(IList <IAstMethodReference> methods, IAstElement target, IList <IAstExpression> arguments)
{
var candidates = GetCandidates(methods, target, arguments)
.GroupBy(c => c.Item2)
.OrderBy(g => g.Key)
.FirstOrDefault();
if (candidates == null)
{
throw new NotImplementedException(string.Format("MethodCallResolver: Could not adapt {0} to call with: {1}.", methods[0].Name, string.Join(", ", arguments.Select(a => a.ExpressionType))));
}
var candidatesAsArray = candidates.ToArray();
if (candidatesAsArray.Length > 1)
{
throw new NotImplementedException(string.Format("MethodCallResolver: Ambiguous best match found for {0}: {1}.", methods[0].Name, string.Join(", ", candidates.AsEnumerable())));
}
return(candidatesAsArray[0].Item1);
}
private IAstMethodReference InnerResolve(IList<IAstMethodReference> methods, IAstElement target, IList<IAstExpression> arguments)
{
var candidates = GetCandidates(methods, target, arguments)
.GroupBy(c => c.Item2)
.OrderBy(g => g.Key)
.FirstOrDefault();
if (candidates == null)
throw new NotImplementedException(string.Format("MethodCallResolver: Could not adapt {0} to call with: {1}.", methods[0].Name, string.Join(", ", arguments.Select(a => a.ExpressionType))));
var candidatesAsArray = candidates.ToArray();
if (candidatesAsArray.Length > 1)
throw new NotImplementedException(string.Format("MethodCallResolver: Ambiguous best match found for {0}: {1}.", methods[0].Name, string.Join(", ", candidates.AsEnumerable())));
return candidatesAsArray[0].Item1;
}
public IAstMethodReference Resolve(IAstMethodReference method, IAstElement target, IList<IAstExpression> arguments)
{
var group = method as AstMethodGroup;
return InnerResolve(group != null ? group.Methods : new[] { method }, target, arguments);
}
public LightAuthoringScope(IAstElement ast)
{
this.ast = ast;
}
public string Transform(IAstElement element)
{
var builder = new StringBuilder();
this.Append(builder, element);
return builder.ToString();
}
protected override IEnumerable<IAstElement> VisitOrTransformChildren(AstElementTransform transform)
{
yield return this.Value = transform(this.Value);
}
public LightAuthoringScope(IAstElement ast)
{
this.ast = ast;
}
public IAstMethodReference Resolve(IAstMethodReference method, IAstElement target, IList <IAstExpression> arguments)
{
var group = method as AstMethodGroup;
return(InnerResolve(group != null ? group.Methods : new[] { method }, target, arguments));
}
public override void Leave(IAstElement o)
{
}
private IEnumerable <Tuple <IAstMethodReference, int> > GetCandidates(IEnumerable <IAstMethodReference> methods, IAstElement target, IList <IAstExpression> arguments)
{
foreach (var method in methods)
{
var parameterTypes = method.ParameterTypes;
var argumentTypes = arguments.Select(a => a.ExpressionType);
if (method.Location == MethodLocation.Extension)
{
argumentTypes = new[] { ((IAstExpression)target).ExpressionType }
}
private IEnumerable<Tuple<IAstMethodReference, int>> GetCandidates(IEnumerable<IAstMethodReference> methods, IAstElement target, IList<IAstExpression> arguments)
{
foreach (var method in methods) {
var parameterTypes = method.ParameterTypes;
var argumentTypes = arguments.Select(a => a.ExpressionType);
if (method.Location == MethodLocation.Extension)
argumentTypes = new[] { ((IAstExpression)target).ExpressionType }.Concat(argumentTypes);
var match = GetOrMakeMatch(method, parameterTypes, argumentTypes);
if (match != null)
yield return match;
}
}
public IAstElement Process(IAstElement element)
{
return Process(element, AllStages);
}
public AstPropertyExpression(IAstElement target, IAstPropertyReference reference)
{
this.Target = target;
this.Reference = reference;
}
public void Compile(IAstElement element)
{
this.compile(element, this);
}
public void Compile(IAstElement element)
{
this.compile(element, this);
}
