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()); }
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 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 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 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); }