public SyntaxTreeNode_Base FindChildByName(params string[] name)
{
SyntaxTreeNode_Base result = this;
foreach (var n in name)
{
var node = result as SyntaxTreeNode_Rule;
if (node == null)
{
return(null);
}
var children = node.nodes;
result = null;
for (var i = 0; i < node.NumValidNodes; i++)
{
var child = children[i];
if (child.ParseNode != null && child.ParseNode.ToString() == n)
{
result = child;
break;
}
}
if (result == null)
{
return(null);
}
}
return(result);
}
public override TypeDefinitionBase ReturnType()
{
if (returnType == null)
{
if (kind == SymbolKind.Constructor)
{
return(parentSymbol as TypeDefinitionBase ?? unknownType);
}
if (declarations != null)
{
SyntaxTreeNode_Base refNode = null;
switch (declarations[0].parseTreeNode.RuleName)
{
case "methodDeclaration":
case "interfaceMethodDeclaration":
refNode = declarations[0].parseTreeNode.FindPreviousNode();
break;
default:
refNode = declarations[0].parseTreeNode.Parent.Parent.ChildAt(declarations[0].parseTreeNode.Parent.m_iChildIndex - 1);
break;
}
if (refNode == null)
{
Debug.LogError("Could not find method return type from node: " + declarations[0].parseTreeNode);
}
returnType = refNode != null ? new SymbolReference(refNode) : null;
}
}
return(returnType == null ? unknownType : returnType.Definition as TypeDefinitionBase ?? unknownType);
}
public static void GetCompletions(IdentifierCompletionsType completionTypes, SyntaxTreeNode_Base parseTreeNode, HashSet <SymbolDefinition> completionSymbols, string assetPath)
{
#if false
var stopwatch = new Stopwatch();
stopwatch.Start();
GetCompletions_Profiled(completionTypes, parseTreeNode, completionSymbols, assetPath);
stopwatch.Stop();
Debug.Log("GetCompletions: " + stopwatch.ElapsedMilliseconds + "ms");
}
public static SymbolDefinition GetResolvedSymbol(SyntaxTreeNode_Base baseNode)
{
#if false
var stopwatch = new Stopwatch();
stopwatch.Start();
var result = GetResolvedSymbol_Internal(baseNode);
stopwatch.Stop();
Debug.Log("GetResolvedSymbol: " + stopwatch.ElapsedMilliseconds + "ms");
return(result);
}
public bool IsAncestorOf(SyntaxTreeNode_Base node)
{
while (node != null)
{
if (node.Parent == this)
{
return(true);
}
else
{
node = node.Parent;
}
}
return(false);
}
public override void Resolve(SyntaxTreeNode_Leaf leaf, int numTypeArgs, bool asTypeOnly)
{
leaf.ResolvedSymbol = null;
if (numTypeArgs == 0 && !asTypeOnly)
{
SyntaxTreeNode_Base target = null;
if (leaf.m_iChildIndex == 0 && leaf.Parent != null && leaf.Parent.Parent == parseTreeNode)
{
var node = parseTreeNode
.Parent
.Parent
.Parent;
if (node.RuleName == "objectCreationExpression")
{
target = node.Parent.NodeAt(1);
}
else
{
target = node.LeafAt(0);
}
if (target != null)
{
var targetSymbol = target.ResolvedSymbol;
if (targetSymbol != null)
{
targetSymbol = targetSymbol.TypeOf();
}
else
{
targetSymbol = SymbolDefinition.ResolveNode(target, parentScope);
}
if (targetSymbol != null)
{
targetSymbol.ResolveMember(leaf, parentScope, 0, false);
}
return;
}
}
}
base.Resolve(leaf, numTypeArgs, asTypeOnly);
}
public override void GetCompletionData(Dictionary <string, SymbolDefinition> data, bool fromInstance, SD_Assembly assembly)
{
var baseNode = completionNode;
if (baseNode.Parent != null && (baseNode.Parent == parseTreeNode || baseNode.m_iChildIndex == 0 && baseNode.Parent.Parent == parseTreeNode))
{
SymbolDefinition target = null;
SyntaxTreeNode_Base targetNode = null;
var node = parseTreeNode
.Parent
.Parent
.Parent;
if (node.RuleName == "objectCreationExpression")
{
targetNode = node.Parent;
target = SymbolDefinition.ResolveNode(targetNode);
var targetAsType = target as TypeDefinitionBase;
if (targetAsType != null)
{
target = targetAsType.GetThisInstance();
}
}
else
{
targetNode = node.Parent.LeafAt(0);
target = SymbolDefinition.ResolveNode(node.Parent.LeafAt(0));
}
if (target != null)
{
HashSet <SymbolDefinition> completions = new HashSet <SymbolDefinition>();
SymbolResolver.GetCompletions(IdentifierCompletionsType.Member, targetNode, completions, completionAssetPath);
foreach (var symbol in completions)
{
data.Add(symbol.name, symbol);
}
}
}
else
{
base.GetCompletionData(data, fromInstance, assembly);
}
}
private static void GetMemberCompletions(SymbolDefinition targetDef, SyntaxTreeNode_Base parseTreeNode,
SD_Assembly assemblyDefinition, Dictionary <string, SymbolDefinition> d, bool includeExtensionMethods)
{
if (targetDef != null)
{
var typeOf = targetDef.TypeOf();
var flags = BindingFlags.Instance | BindingFlags.Static;
switch (targetDef.kind)
{
case SymbolKind.None:
case SymbolKind.Error:
break;
case SymbolKind.Namespace:
case SymbolKind.Interface:
case SymbolKind.Struct:
case SymbolKind.Class:
case SymbolKind.TypeParameter:
case SymbolKind.Delegate:
flags = BindingFlags.Static;
break;
case SymbolKind.Enum:
flags = BindingFlags.Static;
break;
case SymbolKind.Field:
case SymbolKind.ConstantField:
case SymbolKind.LocalConstant:
case SymbolKind.Property:
case SymbolKind.Event:
case SymbolKind.Indexer:
case SymbolKind.Method:
case SymbolKind.MethodGroup:
case SymbolKind.Constructor:
case SymbolKind.Destructor:
case SymbolKind.Operator:
case SymbolKind.Accessor:
case SymbolKind.Parameter:
case SymbolKind.CatchParameter:
case SymbolKind.Variable:
case SymbolKind.ForEachVariable:
case SymbolKind.FromClauseVariable:
case SymbolKind.EnumMember:
flags = BindingFlags.Instance;
break;
case SymbolKind.BaseTypesList:
case SymbolKind.TypeParameterConstraintList:
flags = BindingFlags.Static;
break;
case SymbolKind.Instance:
flags = BindingFlags.Instance;
break;
case SymbolKind.Null:
return;
default:
throw new ArgumentOutOfRangeException();
}
//targetDef.kind = targetDef is TypeDefinitionBase && targetDef.kind != SymbolKind.Enum ? BindingFlags.Static : targetDef is InstanceDefinition ? BindingFlags.Instance : 0;
TypeDefinitionBase contextType = null;
for (var n = parseTreeNode as SyntaxTreeNode_Rule ?? parseTreeNode.Parent; n != null; n = n.Parent)
{
var s = n.scope as Scope_SymbolDeclaration;
if (s != null)
{
contextType = s.declaration.definition as TypeDefinitionBase;
if (contextType != null)
{
break;
}
}
}
AccessLevelMask mask =
typeOf == contextType || typeOf.IsSameOrParentOf(contextType) ? AccessLevelMask.Private | AccessLevelMask.Protected | AccessLevelMask.Internal | AccessLevelMask.Public :
contextType != null && contextType.DerivesFrom(typeOf as TypeDefinitionBase) ? AccessLevelMask.Protected | AccessLevelMask.Internal | AccessLevelMask.Public :
AccessLevelMask.Internal | AccessLevelMask.Public;
if (typeOf.Assembly == null || !typeOf.Assembly.InternalsVisibleIn(assemblyDefinition))
{
mask &= ~AccessLevelMask.Internal;
}
typeOf.GetMembersCompletionData(d, flags, mask, assemblyDefinition);
if (includeExtensionMethods && flags == BindingFlags.Instance &&
(typeOf.kind == SymbolKind.Class || typeOf.kind == SymbolKind.Struct || typeOf.kind == SymbolKind.Interface || typeOf.kind == SymbolKind.Enum))
{
var enclosingScopeNode = parseTreeNode as SyntaxTreeNode_Rule ?? parseTreeNode.Parent;
while (enclosingScopeNode != null && enclosingScopeNode.scope == null)
{
enclosingScopeNode = enclosingScopeNode.Parent;
}
var enclosingScope = enclosingScopeNode != null ? enclosingScopeNode.scope : null;
if (enclosingScope != null)
{
enclosingScope.GetExtensionMethodsCompletionData(typeOf as TypeDefinitionBase, d);
}
}
}
}
public static void GetCompletions_Profiled(IdentifierCompletionsType completionTypes, ParseTree.BaseNode parseTreeNode, HashSet <SymbolDefinition> completionSymbols, string assetPath)
{
#endif
try
{
var d = new Dictionary <string, SymbolDefinition>();
var assemblyDefinition = SD_Assembly.FromAssetPath(assetPath);
if ((completionTypes & IdentifierCompletionsType.MemberName) != 0)
{
SyntaxTreeNode_Base targetNode = null;
var node = parseTreeNode.Parent;
if (node.RuleName != "objectOrCollectionInitializer")
{
if (node.RuleName != "objectInitializer")
{
if (node.RuleName == "memberInitializerList")
{
node = node.Parent; // objectInitializer
}
}
node = node.Parent; // objectOrCollectionInitializer
}
node = node.Parent;
if (node.RuleName == "objectCreationExpression")
{
targetNode = node.Parent;
}
else // node is memberInitializer
{
targetNode = node.LeafAt(0);
}
var targetDef = targetNode != null?SymbolDefinition.ResolveNode(targetNode) : null;
if (targetDef != null)
{
GetMemberCompletions(targetDef, parseTreeNode, assemblyDefinition, d, false);
var filteredData = new Dictionary <string, SymbolDefinition>();
foreach (var kv in d)
{
var symbol = kv.Value;
if (symbol.kind == SymbolKind.Field && (symbol.modifiers & Modifiers.ReadOnly) == 0 ||
symbol.kind == SymbolKind.Property && symbol.FindName("set", 0, false) != null)
{
filteredData[kv.Key] = symbol;
}
}
d = filteredData;
}
var targetType = targetDef != null?targetDef.TypeOf() as TypeDefinitionBase : null;
if (targetType == null || !targetType.DerivesFrom(SymbolDefinition.builtInTypes_IEnumerable))
{
completionSymbols.Clear();
completionSymbols.UnionWith(d.Values);
return;
}
}
if ((completionTypes & IdentifierCompletionsType.Member) != 0)
{
var target = parseTreeNode.FindPreviousNode();
if (target != null)
{
var targetAsNode = target as SyntaxTreeNode_Rule;
if (targetAsNode != null && targetAsNode.RuleName == "primaryExpressionPart")
{
var node0 = targetAsNode.NodeAt(0);
if (node0 != null && node0.RuleName == "arguments")
{
target = target.FindPreviousNode();
targetAsNode = target as SyntaxTreeNode_Rule;
}
}
//Debug.Log(targetAsNode ?? target.parent);
ResolveNode(targetAsNode ?? target.Parent);
var targetDef = GetResolvedSymbol(targetAsNode ?? target.Parent);
GetMemberCompletions(targetDef, parseTreeNode, assemblyDefinition, d, true);
}
}
else if (parseTreeNode == null)
{
#if SI3_WARNINGS
Debug.LogWarning(completionTypes);
#endif
}
else
{
Scope_Base.completionNode = parseTreeNode;
Scope_Base.completionAssetPath = assetPath;
if (parseTreeNode.IsLit("=>"))
{
parseTreeNode = parseTreeNode.Parent.NodeAt(parseTreeNode.m_iChildIndex + 1) ?? parseTreeNode;
}
if (parseTreeNode.IsLit("]") && parseTreeNode.Parent.RuleName == "attributes")
{
parseTreeNode = parseTreeNode.Parent.Parent.NodeAt(parseTreeNode.Parent.m_iChildIndex + 1);
}
var enclosingScopeNode = parseTreeNode as SyntaxTreeNode_Rule ?? parseTreeNode.Parent;
if (enclosingScopeNode != null && (enclosingScopeNode.scope is Scope_SymbolDeclaration) &&
(parseTreeNode.IsLit(";") || parseTreeNode.IsLit("}")) &&
enclosingScopeNode.GetLastLeaf() == parseTreeNode)
{
enclosingScopeNode = enclosingScopeNode.Parent;
}
while (enclosingScopeNode != null && enclosingScopeNode.scope == null)
{
enclosingScopeNode = enclosingScopeNode.Parent;
}
if (enclosingScopeNode != null)
{
var lastLeaf = parseTreeNode as SyntaxTreeNode_Leaf ??
((SyntaxTreeNode_Rule)parseTreeNode).GetLastLeaf() ??
((SyntaxTreeNode_Rule)parseTreeNode).FindPreviousLeaf();
Scope_Base.completionAtLine = lastLeaf != null ? lastLeaf.Line : 0;
Scope_Base.completionAtTokenIndex = lastLeaf != null ? lastLeaf.TokenIndex : 0;
enclosingScopeNode.scope.GetCompletionData(d, true, assemblyDefinition);
}
}
completionSymbols.UnionWith(d.Values);
}
catch (Exception e)
{
Debug.LogException(e);
}
}
public SymbolReference(SyntaxTreeNode_Base node)
{
parseTreeNode = node;
}
public void ImportNamespace(string namespaceToImport, SyntaxTreeNode_Base declaringNode)
{
throw new NotImplementedException();
}
public override SymbolDefinition TypeOf()
{
if (_resolvingTypeOf)
{
return(unknownType);
}
_resolvingTypeOf = true;
if (type != null && (type.Definition == null || !type.Definition.IsValid()))
{
type = null;
}
if (type != null && type.Definition.kind == SymbolKind.Error)
{
type = null;
}
if (type == null)
{
{
SymbolDeclaration decl = declarations != null?declarations.FirstOrDefault() : null;
if (decl != null)
{
SyntaxTreeNode_Base typeNode = null;
switch (decl.kind)
{
case SymbolKind.Parameter:
if (decl.parseTreeNode.RuleName == "implicitAnonymousFunctionParameter")
{
type = TypeOfImplicitParameter(decl);
}
else
{
typeNode = decl.parseTreeNode.FindChildByName("type");
type = typeNode != null ? new SymbolReference(typeNode) : null;//"System.Object" };
}
break;
case SymbolKind.Field:
typeNode = decl.parseTreeNode.Parent.Parent.Parent.FindChildByName("type");
type = typeNode != null ? new SymbolReference(typeNode) : null;//"System.Object" };
break;
case SymbolKind.EnumMember:
type = new SymbolReference(parentSymbol);
break;
case SymbolKind.ConstantField:
case SymbolKind.LocalConstant:
//typeNode = decl.parseTreeNode.parent.parent.ChildAt(1);
//break;
switch (decl.parseTreeNode.Parent.Parent.RuleName)
{
case "constantDeclaration":
case "localDeclaration_Constant":
typeNode = decl.parseTreeNode.Parent.Parent.ChildAt(1);
break;
default:
typeNode = decl.parseTreeNode.Parent.Parent.Parent.FindChildByName("IDENTIFIER");
break;
}
type = typeNode != null ? new SymbolReference(typeNode) : null;
break;
case SymbolKind.Property:
case SymbolKind.Indexer:
typeNode = decl.parseTreeNode.Parent.FindChildByName("type");
type = typeNode != null ? new SymbolReference(typeNode) : null;
break;
case SymbolKind.Event:
typeNode = decl.parseTreeNode.FindParentByName("eventDeclaration").ChildAt(1);
type = typeNode != null ? new SymbolReference(typeNode) : null;
break;
case SymbolKind.Variable:
if (decl.parseTreeNode != null && decl.parseTreeNode.Parent != null && decl.parseTreeNode.Parent.Parent != null)
{
typeNode = decl.parseTreeNode.Parent.Parent.FindChildByName("localVariableType");
}
type = typeNode != null ? new SymbolReference(typeNode) : null;
break;
case SymbolKind.ForEachVariable:
if (decl.parseTreeNode != null)
{
typeNode = decl.parseTreeNode.FindChildByName("localVariableType");
}
type = typeNode != null ? new SymbolReference(typeNode) : null;
break;
case SymbolKind.FromClauseVariable:
type = null;
if (decl.parseTreeNode != null)
{
typeNode = decl.parseTreeNode.FindChildByName("type");
type = typeNode != null
? new SymbolReference(typeNode)
: new SymbolReference(EnumerableElementType(decl.parseTreeNode.NodeAt(-1)));
}
break;
case SymbolKind.CatchParameter:
if (decl.parseTreeNode != null)
{
typeNode = decl.parseTreeNode.Parent.FindChildByName("exceptionClassType");
}
type = typeNode != null ? new SymbolReference(typeNode) : null;
break;
default:
Debug.LogError(decl.kind);
break;
}
}
}
}
var result = type != null ? type.Definition : unknownType;
_resolvingTypeOf = false;
return(result);
}
public SyntaxTreeNode_Base NameNode()
{
if (parseTreeNode == null || parseTreeNode.NumValidNodes == 0)
{
return(null);
}
SyntaxTreeNode_Base nameNode = null;
switch (parseTreeNode.RuleName)
{
case "Declaration_Namespace":
nameNode = parseTreeNode.ChildAt(1);
var nameNodeAsNode = nameNode as SyntaxTreeNode_Rule;
if (nameNodeAsNode != null && nameNodeAsNode.NumValidNodes != 0)
{
nameNode = nameNodeAsNode.ChildAt(-1) ?? nameNode;
}
break;
case "Directive_UsingAlias":
nameNode = parseTreeNode.ChildAt(0);
break;
case "interfaceDeclaration":
case "structDeclaration":
case "classDeclaration":
case "enumDeclaration":
nameNode = parseTreeNode.ChildAt(1);
break;
case "delegateDeclaration":
nameNode = parseTreeNode.ChildAt(2);
break;
case "eventDeclarator":
case "eventWithAccessorsDeclaration":
case "propertyDeclaration":
case "interfacePropertyDeclaration":
case "variableDeclarator":
case "localVariableDeclarator":
case "constantDeclarator":
case "interfaceMethodDeclaration":
case "catchExceptionIdentifier":
nameNode = parseTreeNode.ChildAt(0);
break;
case "methodDeclaration":
case "constructorDeclaration":
var methodHeaderNode = parseTreeNode.NodeAt(0);
if (methodHeaderNode != null && methodHeaderNode.NumValidNodes > 0)
{
nameNode = methodHeaderNode.ChildAt(0);
}
break;
case "methodHeader":
case "constructorDeclarator":
nameNode = parseTreeNode.ChildAt(0);
break;
case "destructorDeclarator":
nameNode = parseTreeNode.FindChildByName("IDENTIFIER");
break;
case "fixedParameter":
case "operatorParameter":
case "parameterArray":
case "explicitAnonymousFunctionParameter":
nameNode = parseTreeNode.FindChildByName("NAME");
break;
case "implicitAnonymousFunctionParameter":
nameNode = parseTreeNode.ChildAt(0);
break;
case "typeParameter":
nameNode = parseTreeNode.ChildAt(0);
break;
case "enumMemberDeclaration":
if (parseTreeNode.ChildAt(0) is SyntaxTreeNode_Rule)
{
nameNode = parseTreeNode.ChildAt(1);
}
else
{
nameNode = parseTreeNode.ChildAt(0);
}
break;
case "statementList":
return(null);
case "lambdaExpression":
case "anonymousMethodExpression":
return(parseTreeNode);
case "interfaceTypeList":
nameNode = parseTreeNode.ChildAt(0);
break;
case "foreachStatement":
case "fromClause":
nameNode = parseTreeNode.FindChildByName("NAME");
break;
case "getAccessorDeclaration":
case "interfaceGetAccessorDeclaration":
case "setAccessorDeclaration":
case "interfaceSetAccessorDeclaration":
case "addAccessorDeclaration":
case "removeAccessorDeclaration":
nameNode = parseTreeNode.FindChildByName("IDENTIFIER");
break;
case "indexerDeclaration":
case "interfaceIndexerDeclaration":
case "labeledStatement":
return(parseTreeNode.ChildAt(0));
case "conversionOperatorDeclarator":
case "operatorDeclarator":
case "Directive_UsingNamespace":
case "typeParameterConstraintsClause":
return(null);
default:
Debug.LogWarning("Don't know how to extract symbol name from: " + parseTreeNode);
return(null);
}
return(nameNode);
}
public abstract IdentifierCompletionsType GetCompletionTypes(SyntaxTreeNode_Base afterNode);
