/// <summary>
/// Calls the custom function.
/// </summary>
/// <param name="name">Name of the function</param>
/// <param name="exp"></param>
/// <returns></returns>
public object Call(string name, FunctionCallExpr exp, IAstVisitor visitor)
{
var objectName = name;
var method = string.Empty;
Func<string, string, FunctionCallExpr, object> callback = null;
// Contains callback for full function name ? e.g. CreateUser
if (_customCallbacks.ContainsKey(name))
callback = _customCallbacks[name];
// Contains callback that handles multiple methods on a "object".
// e.g. Blog.Create, Blog.Delete etc.
if (name.Contains("."))
{
var ndxDot = name.IndexOf(".");
objectName = name.Substring(0, ndxDot);
method = name.Substring(ndxDot + 1);
if (_customCallbacks.ContainsKey(objectName + ".*"))
callback = _customCallbacks[objectName + ".*"];
}
if (callback == null)
return LObjects.Null;
// 1. Resolve parameter froms expressions into Lang values.
ParamHelper.ResolveParametersToHostLangValues(exp.ParamListExpressions, exp.ParamList, visitor);
object result = callback(objectName, method, exp);
return result;
}
internal FieldReferenceReflectionEmitter(MemberReferenceExpression memberReferenceExpression,
Type target,
MemberInfo member,
ILGenerator ilGenerator,
IOpCodeIndexer instructionsIndexer,
IAstVisitor<ILGenerator, AstNode> visitor,
List<LocalBuilder> locals,
bool isSetter = false)
: base(memberReferenceExpression, target, member, ilGenerator, instructionsIndexer, visitor, locals) {
FieldReference = MemberReference.Annotation<FieldReference>();
IsByRef = MemberReference.Parent is DirectionExpression;
Type = FieldReference.FieldType.GetActualType();
FieldInfo = FieldReference.GetActualField();
NonPublic = !((FieldInfo.Attributes & (_publicFieldAttributes)) == _publicFieldAttributes);
if (isSetter) {
_emitAction = EmitStoreFieldReference;
_emitPrivateAction = EmitPrivateStoreFieldReference;
}
else {
_emitAction = EmitLoadFieldReference;
_emitPrivateAction = EmitPrivateLoadFieldReference;
}
}
/// <summary>
/// Sets a value on a member of a basic type.
/// </summary>
/// <param name="ctx">The context of the runtime</param>
/// <param name="node">The assignment ast node</param>
/// <param name="isDeclaration">Whether or not this is a declaration</param>
/// <param name="varExp">The expression representing the index of the instance to set</param>
/// <param name="valExp">The expression representing the value to set</param>
public static void SetVariableValue(Context ctx, IAstVisitor visitor, AstNode node, bool isDeclaration, Expr varExp, Expr valExp)
{
string varname = ((VariableExpr)varExp).Name;
// Case 1: var result;
if (valExp == null)
{
ctx.Memory.SetValue(varname, LObjects.Null, isDeclaration);
}
// Case 2: var result = <expression>;
else
{
var result = valExp.Evaluate(visitor);
// Check for type: e.g. LFunction ? when using Lambda?
if (result != null && result != LObjects.Null)
{
var lobj = result as LObject;
if (lobj != null && lobj.Type.TypeVal == TypeConstants.Function)
{
// 1. Define the function in global symbol scope
SymbolHelper.ResetSymbolAsFunction(varExp.SymScope, varname, lobj);
}
}
// CHECK_LIMIT:
ctx.Limits.CheckStringLength(node, result);
ctx.Memory.SetValue(varname, result, isDeclaration);
}
// LIMIT CHECK
ctx.Limits.CheckScopeCount(varExp);
ctx.Limits.CheckScopeStringLength(varExp);
}
public static void AcceptChildren(this AstNode node, IAstVisitor visitor)
{
foreach (AstNode child in node.Children)
{
child.AcceptVisitor(visitor);
}
}
/// <summary>
/// Evaluate the aggregate expression.
/// </summary>
/// <returns></returns>
public override object DoEvaluate(IAstVisitor visitor)
{
var dataSource = _source.Evaluate(visitor) as LObject;
ExceptionHelper.NotNull(this, dataSource, "aggregation(min/max)");
List<object> items = null;
// Check 1: Could have supplied a single number e.g. sum(2) so just return 2
if (dataSource.Type == LTypes.Number)
return dataSource.Clone();
// Check 2: Expect array
if (dataSource.Type != LTypes.Array)
throw new NotSupportedException(_aggregateType + " not supported for list type of " + dataSource.GetType());
items = dataSource.GetValue() as List<object>;
var val = 0.0;
if (_aggregateType == "sum")
val = items.Sum(item => GetValue(item));
else if (_aggregateType == "avg")
val = items.Average(item => GetValue(item));
else if (_aggregateType == "min")
val = items.Min(item => GetValue(item));
else if (_aggregateType == "max")
val = items.Max(item => GetValue(item));
else if (_aggregateType == "count" || _aggregateType == "number")
val = items.Count;
return new LNumber(val);
}
public object RunTraversal(IAstVisitor visitor, ITraversalStrategy strategy)
{
visitor.StartSession(Expression);
object traversalResult;
try
{
strategy.Initialize(Expression);
while (strategy.HasNext())
{
try
{
var current = strategy.Next();
current.Accept(visitor);
}
catch (RestartTraversalException rte)
{
// Expression.Analyze(new TreeDumper());
strategy.Restart(rte.Root);
}
}
}
finally
{
traversalResult = visitor.FinishSession();
}
return traversalResult;
}
/// <summary>
/// Sets a value on a member of a basic type.
/// </summary>
/// <param name="ctx">The context of the runtime</param>
/// <param name="varExp">The expression representing the index of the instance to set</param>
/// <param name="valExp">The expression representing the value to set</param>
/// <param name="node">The assignment ast node</param>
public static void SetIndexValue(Context ctx, IAstVisitor visitor, AstNode node, Expr varExp, Expr valExp)
{
// 1. Get the value that is being assigned.
var val = valExp.Evaluate(visitor) as LObject;
// 2. Check the limit if string.
ctx.Limits.CheckStringLength(node, val);
// 3. Evaluate expression to get index info.
var indexExp = varExp.Evaluate(visitor) as IndexAccess;
if (indexExp == null)
throw ComLib.Lang.Helpers.ExceptionHelper.BuildRunTimeException(node, "Value to assign is null");
// 4. Get the target of the index access and the name / number to set.
var target = indexExp.Instance;
var memberNameOrIndex = indexExp.MemberName;
// Get methods associated with type.
var methods = ctx.Methods.Get(target.Type);
// Case 1: users[0] = 'kishore'
if (target.Type == LTypes.Array)
{
var index = Convert.ToInt32(((LNumber)memberNameOrIndex).Value);
methods.SetByNumericIndex(target, index, val);
}
// Case 2: users['total'] = 20
else if (target.Type == LTypes.Map)
{
var name = ((LString)memberNameOrIndex).Value;
methods.SetByStringMember(target, name, val);
}
}
public PropertyReferenceReflectionEmitter(MemberReferenceExpression memberReferenceExpression,
Type target,
MemberInfo member,
ILGenerator ilGenerator,
IOpCodeIndexer instructionsIndexer,
IAstVisitor<ILGenerator, AstNode> visitor,
List<LocalBuilder> locals,
bool isSetter = false)
: base(memberReferenceExpression, target, member, ilGenerator, instructionsIndexer, visitor, locals) {
var propertyInfo = Member as PropertyInfo;
_isSetter = isSetter;
_propertyDefinition = MemberReference.Annotation<Cecil.PropertyDefinition>();
NonPublic = !_propertyDefinition.GetMethod.IsPublic;
Type = _propertyDefinition.PropertyType.GetActualType();
if (isSetter) {
_propertyMethod = propertyInfo.GetSetMethod(NonPublic);
_emitPrivateAction = EmitPrivateStorePropertyReference;
}
else {
_propertyMethod = propertyInfo.GetGetMethod(NonPublic);
_emitPrivateAction = EmitPrivateLoadPropertyReference;
}
}
internal EventReferenceReflectionEmitter(MemberReferenceExpression memberReferenceExpression,
Type target,
MemberInfo member,
ILGenerator ilGenerator,
IOpCodeIndexer instructionsIndexer,
IAstVisitor<ILGenerator, AstNode> visitor,
List<LocalBuilder> locals)
: base(memberReferenceExpression, target, member, ilGenerator, instructionsIndexer, visitor, locals) { }
internal AbstractReflectionEmitter(ILGenerator ilGenerator,
IOpCodeIndexer instructionsIndexer,
IAstVisitor<ILGenerator, AstNode> visitor,
List<LocalBuilder> locals)
: base(ilGenerator, instructionsIndexer) {
Visitor = visitor;
Locals = locals;
}
public virtual void AcceptVisitor(IAstVisitor visitor)
{
visitor.BeginVisit(this);
if (ChildNodes.Count > 0)
foreach (AstNode node in ChildNodes)
node.AcceptVisitor(visitor);
visitor.EndVisit(this);
}
public virtual object AcceptChildren(IAstVisitor visitor, object data)
{
foreach (INode child in children) {
Debug.Assert(child != null);
child.AcceptVisitor(visitor, data);
}
return data;
}
public DecoratedOutputFormatter(IOutputFormatter formatter, IAstVisitor visitor)
{
if (formatter == null)
throw new ArgumentNullException(nameof(formatter));
if (visitor == null)
throw new ArgumentNullException(nameof(visitor));
_formatter = formatter;
_visitor = visitor;
}
internal MultipuleAssignmentEmitter(MemberReferenceExpression memberReferenceExpression,
Expression assignor,
ILGenerator ilGenerator,
IOpCodeIndexer instructionsIndexer,
IAstVisitor<ILGenerator, AstNode> visitor,
List<LocalBuilder> locals)
: base(memberReferenceExpression, ilGenerator, instructionsIndexer, visitor, locals) {
_assignorExpression = assignor;
}
/// <summary>
/// Gets a member access object representing the a member access.
/// </summary>
/// <param name="node"></param>
/// <param name="ctx"></param>
/// <param name="varExp"></param>
/// <param name="memberName"></param>
/// <returns></returns>
public static MemberAccess GetMemberAccess(AstNode node, Context ctx, Expr varExp, string memberName, IAstVisitor visitor)
{
var isVariableExp = varExp.IsNodeType(NodeTypes.SysVariable);
var variableName = isVariableExp ? ((VariableExpr) varExp).Name : string.Empty;
// CASE 1: External function call "user.create"
if (isVariableExp && FunctionHelper.IsExternalFunction(ctx.ExternalFunctions, variableName, memberName))
return new MemberAccess(MemberMode.FunctionExternal) {Name = variableName, MemberName = memberName};
// CASE 2. Static method call: "Person.Create"
if (isVariableExp)
{
var result = MemberHelper.IsExternalTypeName(ctx.Memory, ctx.Types, variableName);
if (result.Success)
return MemberHelper.GetExternalTypeMember(node, (Type) result.Item, variableName, null, memberName, true);
}
// CASE 3: Module
if (varExp.IsNodeType(NodeTypes.SysVariable))
{
var name = varExp.ToQualifiedName();
if (!ctx.Memory.Contains(name))
{
var modresult = ResolveSymbol(varExp.SymScope, name);
if (modresult != null) return modresult;
}
}
// CASE 4: Nested member.
var res = varExp.Visit(visitor);
if (res is MemberAccess )
{
return res as MemberAccess;
}
var obj = res as LObject;
// Check for empty objects.
ExceptionHelper.NotNull(node, obj, "member access");
var type = obj.Type;
// Case 3: Method / Property on FluentScript type
bool isCoreType = obj.Type.IsBuiltInType();
if (isCoreType)
{
var result = MemberHelper.GetLangBasicTypeMember(node, ctx.Methods, obj, memberName);
return result;
}
// CASE 4: Method / Property on External/Host language type (C#)
var lclass = obj as LClass;
var lclassType = lclass.Type as LClassType;
var member = MemberHelper.GetExternalTypeMember(node, lclassType.DataType, variableName, lclass.Value, memberName, false);
return member;
}
public virtual object AcceptChildren(IAstVisitor visitor, object data)
{
foreach (INode child in children) {
if (child != null)
//Debug.Assert(child != null);
child.AcceptVisitor(visitor, data);
else
System.Diagnostics.Debug.WriteLine("In AcceptChildren child == null");
}
return data;
}
public virtual object AcceptChildren(IAstVisitor visitor, object data)
{
foreach (INode child in children) {
if (child != null)
//Debug.Assert(child != null);
child.AcceptVisitor(visitor, data);
else
PublicDI.log.error("In AcceptChildren child == null");
}
return data;
}
public PatternCompiler(ErrorLog errorLog,
SymbolTable symbolTable,
IodineMethod methodBuilder,
int temporary,
IAstVisitor parent)
{
parentVisitor = parent;
this.errorLog = errorLog;
this.methodBuilder = methodBuilder;
this.symbolTable = symbolTable;
this.temporary = temporary;
}
/// <summary>
/// Evaluate
/// </summary>
/// <returns></returns>
public override object DoEvaluate(IAstVisitor visitor)
{
var exePath = "";
var workingDir = "";
var failOnError = false;
LArray args = null;
var exitcode = -1;
/*
try
{
this.ResolveParams();
exePath = this.GetParamValueString(0, false, string.Empty);
workingDir = this.GetParamValueString(1, true, string.Empty);
args = this.GetParamValue(2, true, null) as LArray;
failOnError = this.GetParamValueBool(3, true, false);
// Convert the items in the array to strings.
// TODO: type-changes
//var list = args.Raw;
var list = new List<object>();
var stringArgs = "";
if (args != null && args.Value != null)
{
foreach (var item in args.Value)
{
var lobj = (LObject)item;
stringArgs += Convert.ToString(lobj.GetValue()) + " ";
}
}
var p = new System.Diagnostics.Process();
p.StartInfo.FileName = exePath;
p.StartInfo.Arguments = stringArgs;
p.StartInfo.UseShellExecute = false;
p.StartInfo.CreateNoWindow = true;
p.StartInfo.WorkingDirectory = workingDir;
p.Start();
// TODO: Set up options on this plugin to configure wait time ( indefinite | milliseconds )
p.WaitForExit();
exitcode = p.ExitCode;
}
catch (Exception ex)
{
exitcode = 1;
if (failOnError)
{
var error = string.Format("An error occurred executing external application '{0}', in '{1}', with '{2}'.\r\n"
+ "message: {3}", exePath, workingDir, args, ex.Message);
throw new LangFailException(error, this.Ref.ScriptName, this.Ref.Line);
}
}
*/
return new LNumber(Convert.ToDouble(exitcode));
}
/// <summary>
/// Resolve all the non-named parameter expressions and puts the values into the param list supplied.
/// </summary>
public static void ResolveNonNamedParameters(List<Expr> paramListExpressions, List<object> paramList, IAstVisitor visitor)
{
if (paramListExpressions == null || paramListExpressions.Count == 0)
return;
paramList.Clear();
foreach (var exp in paramListExpressions)
{
object val = exp.Evaluate(visitor);
paramList.Add(val);
}
}
/// <summary>
/// Execute
/// </summary>
public override object DoEvaluate(IAstVisitor visitor)
{
object message = null;
if (Exp != null)
message = Exp.Evaluate(visitor);
var text = (message == null || message == LObjects.Null)
? ""
: ((LObject)message).GetValue().ToString();
throw new LangFailException(text, this.Ref.ScriptName, this.Ref.Line);
}
internal AbstractMemberReferenceEmitter(MemberReferenceExpression memberReferenceExpression,
Type target,
MemberInfo member,
ILGenerator ilGenerator,
IOpCodeIndexer instructionsIndexer,
IAstVisitor<ILGenerator, AstNode> visitor,
List<LocalBuilder> locals)
: base(ilGenerator, instructionsIndexer, visitor, locals) {
Target = target;
Member = member;
MemberReference = memberReferenceExpression;
}
/// <summary>
/// Resolves the parameter expressions to actual values.
/// </summary>
/// <param name="totalParams">The total number of paramters possible</param>
/// <param name="paramListExpressions">The list of expressions that should be evaulated first to pass as parameters</param>
/// <param name="paramList">The list of parameters to a populate from paramListExpressions</param>
/// <param name="indexLookup">The lookup callback to get the index position for named parameters</param>
/// <param name="containsLookup">The lookup callback to determine if the namedparameter exists in the function. </param>
/// <param name="visitor">The visitor that will evaulate the expressions.</param>
public static void ResolveParameters(int totalParams, List<Expr> paramListExpressions, List<object> paramList, Func<NamedParameterExpr, int> indexLookup,
Func<NamedParameterExpr, bool> containsLookup, IAstVisitor visitor)
{
if (paramListExpressions == null || paramListExpressions.Count == 0)
return;
// 1. Determine if named params exist.
bool hasNamedParams = ParamHelper.HasNamedParameters(paramListExpressions);
// 2. If no named parameters, simply eval parameters and return.
if (!hasNamedParams)
{
ResolveNonNamedParameters(paramListExpressions, paramList, visitor);
return;
}
// Start of named parameter evaluation.
// 1. Clear existing list of value.
paramList.Clear();
// 2. Set all args to null. [null, null, null, null, null]
for (int ndx = 0; ndx < totalParams; ndx++)
paramList.Add(LObjects.Null);
// 3. Now go through each argument and replace the nulls with actual argument values.
// Each null should be replaced at the correct index.
// [true, 20.68, new Date(2012, 8, 10), null, 'fluentscript']
for (int ndx = 0; ndx < paramListExpressions.Count; ndx++)
{
var exp = paramListExpressions[ndx];
// 4. Named arg? Evaluate and put its value into the appropriate index of the args list.
if (exp.IsNodeType(NodeTypes.SysNamedParameter))
{
var namedParam = exp as NamedParameterExpr;
object val = namedParam.Visit(visitor);
var contains = containsLookup(namedParam);
if (!contains)
throw ExceptionHelper.BuildRunTimeException(namedParam, "Named parameter : " + namedParam.Name + " does not exist");
int argIndex = indexLookup(namedParam);
paramList[argIndex] = val;
}
else
{
// 5. Expect the position of non-named args should be valid.
// TODO: Semantic analysis is required here once Lint check feature is added.
object val = exp.Visit(visitor);
paramList[ndx] = val;
}
}
}
public void Setup()
{
mocks = new MockRepository();
logger = new NullLogger();
typeResolver = mocks.DynamicMock<ITypeResolver>();
visitor = mocks.DynamicMock<IAstVisitor>();
sources = mocks.DynamicMock<IParsedSourceStorageService>();
parserFactory = mocks.DynamicMock<IParserFactory>();
parser = mocks.DynamicMock<IParser>();
service = new SiteTreeGeneratorService(logger, typeResolver, sources, parserFactory);
path = "~~TemporarySource.cs";
WriteSampleSource(path);
}
/// <summary>
/// Evaluate
/// </summary>
/// <returns></returns>
public override object Evaluate(IAstVisitor visitor)
{
object result = null;
if (this.Ctx != null && this.Ctx.Callbacks.HasAny)
{
Ctx.Callbacks.Notify("expression-on-before-execute", this, this);
result = ExecuteBlock(visitor);
Ctx.Callbacks.Notify("expression-on-after-execute", this, this);
return result;
}
result = ExecuteBlock(visitor);
return result;
}
public void Parse(IAstVisitor visitor, string path)
{
using (TextReader reader = File.OpenText(path))
{
var parser = parserFactory.CreateCSharpParser(reader);
parser.ParseMethodBodies = true;
parser.Parse();
typeResolver.Clear();
visitor.VisitCompilationUnit(parser.CompilationUnit, null);
cache.Add(path, parser);
}
}
public void Setup()
{
_mocks = new MockRepository();
_logger = new NullLogger();
_typeResolver = _mocks.DynamicMock<ITypeResolver>();
_visitor = _mocks.DynamicMock<IAstVisitor>();
_sources = _mocks.DynamicMock<IParsedSourceStorageService>();
_parserFactory = _mocks.DynamicMock<IParserFactory>();
_parser = _mocks.DynamicMock<IParser>();
_service = new SiteTreeGeneratorService(_logger, _typeResolver, _sources, _parserFactory);
_path = "~~TemporarySource.cs";
WriteSampleSource(_path);
}
/// <summary>
/// Evaluate
/// </summary>
/// <returns></returns>
public override object DoEvaluate(IAstVisitor visitor)
{
// var a = 1;
// var b = 2;
// swap a with b;
// var temp = a;
// a = b;
// b = temp;
var val1 = this.Ctx.Memory.Get<object>(_name1);
var val2 = this.Ctx.Memory.Get<object>(_name2);
this.Ctx.Memory.SetValue(_name1, val2);
this.Ctx.Memory.SetValue(_name2, val1);
return val2;
}
/// <summary>
/// Executes the block with callback/template methods.
/// </summary>
protected virtual object ExecuteBlock(IAstVisitor visitor)
{
object result = LObjects.Null;
try
{
OnBlockEnter(visitor);
result = DoEvaluate(visitor);
}
finally
{
OnBlockExit(visitor);
}
return result;
}
/// <summary>
/// Evaluate
/// </summary>
/// <returns></returns>
public override object DoEvaluate(IAstVisitor visitor)
{
var val = "";
// Case 1: $env.sys.systemroot
// Case 2: $env.user.systemroot
if (string.IsNullOrEmpty(_scope))
{
val = System.Environment.GetEnvironmentVariable(_varName);
return new LString(val);
}
EnvironmentVariableTarget target = (_scope == "sys")
? EnvironmentVariableTarget.Machine
: EnvironmentVariableTarget.User;
val = System.Environment.GetEnvironmentVariable(_varName, target);
return new LString(val);
}
public override S AcceptVisitor <T, S> (IAstVisitor <T, S> visitor, T data)
{
return(visitor.VisitPatternPlaceholder(this, child, data));
}
public override void AcceptVisitor(IAstVisitor visitor)
{
visitor.VisitYieldBreakStatement(this);
}
public override void AcceptVisitor(IAstVisitor visitor)
{
visitor.VisitNullNode(this);
}
override public void Accept(IAstVisitor visitor)
{
visitor.OnInterfaceDefinition(this);
}
public override T AcceptVisitor <T> (IAstVisitor <T> visitor)
{
return(visitor.VisitForeachStatement(this));
}
public override void AcceptVisitor(IAstVisitor visitor)
{
visitor.VisitContinueStatement(this);
}
public override S AcceptVisitor <T, S>(IAstVisitor <T, S> visitor, T data)
{
return(visitor.VisitInstanceExpression(this, data));
}
public abstract void AcceptVisitor(IAstVisitor visitor);
public override S AcceptVisitor <T, S>(IAstVisitor <T, S> visitor, T data)
{
return(visitor.VisitSimpleCaseClause(this, data));
}
public abstract T AcceptVisitor <T> (IAstVisitor <T> visitor);
public override S AcceptVisitor <T, S>(IAstVisitor <T, S> visitor, T data)
{
return(visitor.VisitComparisonCaseClause(this, data));
}
public override S AcceptVisitor <T, S> (IAstVisitor <T, S> visitor, T data)
{
return(visitor.VisitContinueStatement(this, data));
}
public override S AcceptVisitor <T, S>(IAstVisitor <T, S> visitor, T data = default(T))
{
return(default(S));
}
public override void AcceptVisitor(IAstVisitor visitor)
{
visitor.VisitIfElseStatement(this);
}
public override T AcceptVisitor <T> (IAstVisitor <T> visitor)
{
return(visitor.VisitPatternPlaceholder(this, child));
}
public override T AcceptVisitor <T>(IAstVisitor <T> visitor)
{
return(visitor.VisitSimpleType(this));
}
override public void Accept(IAstVisitor visitor)
{
visitor.OnContinueStatement(this);
}
public override void Accept(IAstVisitor visior)
{
visior.Visit(this);
}
public override T Accept <T>(IAstVisitor <T> visitor)
{
return(visitor.VisitBlock(this));
}
public override void AcceptVisitor(IAstVisitor visitor)
{
visitor.VisitPatternPlaceholder(this, child);
}
public override void AcceptVisitor(IAstVisitor visitor)
{
visitor.VisitSimpleType(this);
}
public override S AcceptVisitor <T, S>(IAstVisitor <T, S> visitor, T data)
{
return(visitor.VisitYieldBreakStatement(this, data));
}
} // foreach (|var c| in args)
public override void AcceptVisitor(IAstVisitor visitor)
{
visitor.VisitForeachStatement(this);
}
public override T AcceptVisitor <T>(IAstVisitor <T> visitor)
{
return(visitor.VisitYieldBreakStatement(this));
}
public override S AcceptVisitor <T, S> (IAstVisitor <T, S> visitor, T data)
{
return(visitor.VisitCSharpTokenNode(this, data));
}
public override S AcceptVisitor <T, S>(IAstVisitor <T, S> visitor, T data = default(T))
{
return(visitor.VisitNestedTypeDeclaration(this, data));
}
public override S AcceptVisitor <T, S> (IAstVisitor <T, S> visitor, T data)
{
return(visitor.VisitNullNode(this, data));
}
public override T AcceptVisitor <T> (IAstVisitor <T> visitor)
{
return(visitor.VisitNullNode(this));
}
public override T AcceptVisitor <T> (IAstVisitor <T> visitor)
{
return(visitor.VisitContinueStatement(this));
}
public abstract S AcceptVisitor <T, S> (IAstVisitor <T, S> visitor, T data);
