private void CheckReservedWord(ref string name, ISymbol symbol)
{
if (LuaSyntaxNode.IsReservedWord(name))
{
name = localReservedNames_[symbol];
}
}
/// <summary>
/// Initializes a depth-first preorder enumerator for the given node.
/// </summary>
protected void UsingNode(LuaSyntaxNode root)
{
VerifyEnumeratorConsumed();
_node = root;
var nodes = EnumerateNodes(root, dump: false);
_treeEnumerator = nodes.GetEnumerator();
}
public virtual void Visit(LuaSyntaxNode node)
{
if (node is null)
{
return;
}
node.Accept(this);
}
protected void UsingNode(string text, LuaSyntaxNode node, DiagnosticDescription[] expectedErrors)
{
// we validate the text roundtrips
Assert.Equal(text, node.ToFullString());
var actualErrors = node.GetDiagnostics();
actualErrors.Verify(expectedErrors);
UsingNode(node);
}
private static SyntaxNode CheckSerializable(SyntaxNode node)
{
var stream = new MemoryStream();
node.SerializeTo(stream);
stream.Position = 0;
_ = LuaSyntaxNode.DeserializeFrom(stream);
return(node);
}
private bool CheckReservedWord(ref string name, SyntaxNode node)
{
if (LuaSyntaxNode.IsReservedWord(name))
{
name = GetUniqueIdentifier(name, node, 1);
AddReservedMapping(name, node);
return(true);
}
return(false);
}
private static SyntaxTree CheckSerializable(SyntaxTree tree)
{
var stream = new MemoryStream();
var root = tree.GetRoot();
root.SerializeTo(stream);
stream.Position = 0;
_ = LuaSyntaxNode.DeserializeFrom(stream);
return(tree);
}
private bool CheckLocalBadWord(ref string name, SyntaxNode node) {
if (LuaSyntaxNode.IsReservedWord(name)) {
name = GetUniqueIdentifier(name, node, 1);
return true;
}
else if (Utility.IsIdentifierIllegal(ref name)) {
name = GetUniqueIdentifier(name, node, 0);
return true;
}
return false;
}
/// <summary>
/// Called when the syntax walker visits a node.
/// </summary>
/// <param name="node"></param>
public override void Visit(LuaSyntaxNode node)
{
if (node != null)
{
_recursionDepth++;
StackGuard.EnsureSufficientExecutionStack(_recursionDepth);
node.Accept(this);
_recursionDepth--;
}
}
/// <summary>
/// Called when the walker walks into a node.
/// </summary>
/// <param name="node"></param>
protected override void DefaultVisit(LuaSyntaxNode node)
{
foreach (var child in node.ChildNodesAndTokens())
{
if (child.IsToken)
{
if (Depth >= SyntaxWalkerDepth.Token)
{
Visit((SyntaxToken)child);
}
}
else
{
if (Depth >= SyntaxWalkerDepth.Node)
{
Visit((LuaSyntaxNode)child);
}
}
}
}
private IEnumerable <SyntaxNodeOrToken> EnumerateNodes(LuaSyntaxNode node, bool dump)
{
Print(node, dump);
yield return(node);
var stack = new Stack <ChildSyntaxList.Enumerator>(24);
stack.Push(node.ChildNodesAndTokens().GetEnumerator());
Open(dump);
while (stack.Count > 0)
{
var en = stack.Pop();
if (!en.MoveNext())
{
// no more down this branch
Close(dump);
continue;
}
var current = en.Current;
stack.Push(en); // put it back on stack (struct enumerator)
Print(current, dump);
yield return(current);
if (current.IsNode)
{
// not token, so consider children
stack.Push(current.ChildNodesAndTokens().GetEnumerator());
Open(dump);
continue;
}
}
Done(dump);
}
public override LuaSyntaxNode VisitConstructorDeclaration(ConstructorDeclarationSyntax node)
{
IMethodSymbol ctorSymbol = semanticModel_.GetDeclaredSymbol(node);
methodInfos_.Push(new MethodInfo(ctorSymbol));
LuaConstructorAdapterExpressionSyntax function = new LuaConstructorAdapterExpressionSyntax();
PushFunction(function);
bool isStatic = node.Modifiers.IsStatic();
function.AddParameter(LuaIdentifierNameSyntax.This);
var parameterList = (LuaParameterListSyntax)node.ParameterList.Accept(this);
function.ParameterList.Parameters.AddRange(parameterList.Parameters);
if (node.Initializer != null)
{
var symbol = (IMethodSymbol)semanticModel_.GetSymbolInfo(node.Initializer).Symbol;
int ctroCounter = GetConstructorIndex(symbol);
LuaInvocationExpressionSyntax otherCtorInvoke;
if (node.Initializer.IsKind(SyntaxKind.ThisConstructorInitializer))
{
Contract.Assert(ctroCounter != 0);
LuaIdentifierNameSyntax thisCtor = new LuaIdentifierNameSyntax(LuaSyntaxNode.SpecailWord(LuaSyntaxNode.Tokens.Ctor + ctroCounter));
otherCtorInvoke = new LuaInvocationExpressionSyntax(thisCtor);
function.IsInvokeThisCtor = true;
}
else
{
otherCtorInvoke = BuildCallBaseConstructor(symbol.ReceiverType, ctroCounter);
}
otherCtorInvoke.AddArgument(LuaIdentifierNameSyntax.This);
var arguments = BuildArgumentList(symbol, symbol.Parameters, node.Initializer.ArgumentList);
otherCtorInvoke.AddArguments(arguments);
function.AddStatement(otherCtorInvoke);
}
else if (!isStatic)
{
var baseCtorInvoke = BuildCallBaseConstructor(ctorSymbol.ContainingType);
if (baseCtorInvoke != null)
{
function.AddStatement(baseCtorInvoke);
}
}
LuaBlockSyntax block = (LuaBlockSyntax)node.Body.Accept(this);
function.AddStatements(block.Statements);
PopFunction();
if (isStatic)
{
CurType.SetStaticCtor(function);
}
else
{
CurType.AddCtor(function, node.ParameterList.Parameters.Count == 0);
}
methodInfos_.Pop();
return(function);
}
public virtual TResult Visit(LuaSyntaxNode node) => node is null ? default : node.Accept(this);
protected virtual void DefaultVisit(LuaSyntaxNode node)
{
}
