public override void GetCompletionData(Dictionary <string, SymbolDefinition> data, bool fromInstance, SD_Assembly assembly)
{
if (localSymbols != null)
{
foreach (var ls in localSymbols)
{
SymbolDeclaration declaration = ls.declarations.FirstOrDefault();
SyntaxTreeNode_Rule declarationNode = declaration != null ? declaration.parseTreeNode : null;
if (declarationNode == null)
{
continue;
}
var firstLeaf = declarationNode.GetFirstLeaf();
if (firstLeaf != null &&
(firstLeaf.Line > completionAtLine ||
firstLeaf.Line == completionAtLine && firstLeaf.TokenIndex >= completionAtTokenIndex))
{
continue;
}
if (!data.ContainsKey(ls.name))
{
data.Add(ls.name, ls);
}
}
}
base.GetCompletionData(data, fromInstance, assembly);
}
public static SyntaxTreeNode_Rule ResolveNode(SyntaxTreeNode_Rule node)
{
if (node == null)
{
return(null);
}
while (node.Parent != null)
{
switch (node.RuleName)
{
//case "primaryExpression":
case "primaryExpressionStart":
case "primaryExpressionPart":
case "objectCreationExpression":
case "objectOrCollectionInitializer":
case "typeOrGeneric":
case "namespaceOrTypeName":
case "typeName":
case "nonArrayType":
//case "attribute":
case "accessIdentifier":
case "brackets":
case "argumentList":
case "attributeArgumentList":
case "argumentName":
case "attributeMemberName":
case "argument":
case "attributeArgument":
case "attributeArguments":
case "arrayCreationExpression":
case "implicitArrayCreationExpression":
case "arrayInitializer":
case "arrayInitializerList":
case "qidStart":
case "qidPart":
case "memberInitializer":
case "globalNamespace":
node = node.Parent;
continue;
}
break;
}
try
{
var result = SymbolDefinition.ResolveNode(node, null, null, 0);//numTypeArgs);
if (result == null)
{
ResolveChildren(node);
}
}
catch (Exception e)
{
Debug.LogException(e);
return(null);
}
return(node);
}
public override SymbolDefinition ResolveMethodOverloads(SyntaxTreeNode_Rule argumentListNode, SymbolReference[] typeArgs, Scope_Base scope, SyntaxTreeNode_Leaf invokedLeaf)
{
Modifiers[] modifiers;
List <TypeDefinitionBase> argumentTypes;
ProcessArgumentListNode(argumentListNode, out modifiers, out argumentTypes, null);
var resolved = ResolveMethodOverloads(argumentTypes, modifiers, scope, invokedLeaf);
return(resolved);
}
public override SymbolDefinition ResolveMethodOverloads(SyntaxTreeNode_Rule argumentListNode, SymbolReference[] typeArgs, Scope_Base scope, SyntaxTreeNode_Leaf invokedLeaf)
{
if (kind != SymbolKind.MethodGroup)
{
return(null);
}
var genericMethod = ((SD_MethodGroup)referencedSymbol).ResolveMethodOverloads(argumentListNode, typeArgs, scope, invokedLeaf);
if (genericMethod == null || genericMethod.kind != SymbolKind.Method)
{
return(null);
}
return(((SD_Type_Constructed)parentSymbol).GetConstructedMember(genericMethod));
}
static void ResolveChildren(SyntaxTreeNode_Rule node)
{
if (node == null)
{
return;
}
if (node.NumValidNodes != 0)
{
for (var i = 0; i < node.NumValidNodes; ++i)
{
var child = node.ChildAt(i);
var leaf = child as SyntaxTreeNode_Leaf;
if (leaf == null ||
leaf.token != null &&
leaf.token.tokenKind != LexerToken.Kind.Punctuator &&
(leaf.token.tokenKind != LexerToken.Kind.Keyword || SymbolDefinition.builtInTypes.ContainsKey(leaf.token.text)))
{
if (leaf == null)
{
switch (((SyntaxTreeNode_Rule)child).RuleName)
{
case "modifiers":
case "methodBody":
continue;
}
}
var numTypeArgs = 0;
if (SymbolDefinition.ResolveNode(child, null, null, numTypeArgs) == null)
{
var childAsNode = child as SyntaxTreeNode_Rule;
if (childAsNode != null)
{
ResolveChildren(childAsNode);
}
}
}
}
}
}
public override TypeDefinitionBase BaseType()
{
if (resolvingBaseType)
{
return(null);
}
resolvingBaseType = true;
if (baseType != null && (baseType.Definition == null || !baseType.Definition.IsValid()) ||
interfaces != null && interfaces.Exists(x => x.Definition == null || !x.Definition.IsValid()))
{
baseType = null;
interfaces = null;
}
if (baseType == null && interfaces == null)
{
interfaces = new List <SymbolReference>();
SyntaxTreeNode_Rule baseNode = null;
SyntaxTreeNode_Rule interfaceListNode = null;
SymbolDeclaration decl = null;
if (declarations != null)
{
foreach (var d in declarations)
{
if (d != null)
{
baseNode = (SyntaxTreeNode_Rule)d.parseTreeNode.FindChildByName(
d.kind == SymbolKind.Class ? "classBase" :
d.kind == SymbolKind.Struct ? "structInterfaces" :
"interfaceBase");
interfaceListNode = baseNode != null?baseNode.NodeAt(1) : null;
if (baseNode != null)
{
decl = d;
break;
}
}
}
}
if (decl != null)
{
switch (decl.kind)
{
case SymbolKind.Class:
if (interfaceListNode != null)
{
baseType = new SymbolReference(interfaceListNode.ChildAt(0));
if (baseType.Definition.kind == SymbolKind.Interface)
{
interfaces.Add(baseType);
baseType = this != builtInTypes_object?ReflectedTypeReference.ForType(typeof(object)) : null;
}
for (var i = 2; i < interfaceListNode.NumValidNodes; i += 2)
{
interfaces.Add(new SymbolReference(interfaceListNode.ChildAt(i)));
}
}
else
{
baseType = this != builtInTypes_object?ReflectedTypeReference.ForType(typeof(object)) : null;
}
break;
case SymbolKind.Struct:
case SymbolKind.Interface:
baseType = decl.kind == SymbolKind.Struct ?
ReflectedTypeReference.ForType(typeof(ValueType)) :
ReflectedTypeReference.ForType(typeof(object));
if (interfaceListNode != null)
{
for (var i = 0; i < interfaceListNode.NumValidNodes; i += 2)
{
interfaces.Add(new SymbolReference(interfaceListNode.ChildAt(i)));
}
}
break;
case SymbolKind.Enum:
baseType = ReflectedTypeReference.ForType(typeof(Enum));
break;
case SymbolKind.Delegate:
baseType = ReflectedTypeReference.ForType(typeof(MulticastDelegate));
break;
}
}
//Debug.Log("BaseType() of " + this + " is " + (baseType != null ? baseType.definition.ToString() : "null"));
}
var result = baseType != null ? baseType.Definition as TypeDefinitionBase : base.BaseType();
if (result == this)
{
baseType = new SymbolReference(circularBaseType);
result = circularBaseType;
}
resolvingBaseType = false;
return(result);
}
public override TypeDefinitionBase BaseType()
{
if (resolvingBaseType)
{
return(null);
}
resolvingBaseType = true;
if (baseTypeConstraint != null && (baseTypeConstraint.Definition == null || !baseTypeConstraint.Definition.IsValid()) ||
interfacesConstraint != null && interfacesConstraint.Exists(x => x.Definition == null || !x.Definition.IsValid()))
{
baseTypeConstraint = null;
interfacesConstraint = null;
}
if (baseTypeConstraint == null && interfacesConstraint == null)
{
interfacesConstraint = new List <SymbolReference>();
SyntaxTreeNode_Rule clauseNode = null;
if (declarations != null)
{
for (var i = 0; i < declarations.Count; i++)
{
var d = declarations[i];
if (d != null && d.IsValid())
{
SyntaxTreeNode_Rule constraintsNode = null;
var typeParameterListNode = d.parseTreeNode.Parent;
var parentRuleName = typeParameterListNode.Parent.RuleName;
if (parentRuleName == "structDeclaration" ||
parentRuleName == "classDeclaration" ||
parentRuleName == "interfaceDeclaration" ||
parentRuleName == "delegateDeclaration" ||
parentRuleName == "interfaceMethodDeclaration")
{
constraintsNode = typeParameterListNode.Parent.FindChildByName("typeParameterConstraintsClauses") as SyntaxTreeNode_Rule;
}
else if (parentRuleName == "qidStart" || parentRuleName == "qidPart")
{
constraintsNode = typeParameterListNode.Parent
.Parent // qid
.Parent // memberName
.Parent // methodHeader
.FindChildByName("typeParameterConstraintsClauses") as SyntaxTreeNode_Rule;
}
if (constraintsNode != null)
{
for (var j = 0; j < constraintsNode.NumValidNodes; j++)
{
clauseNode = constraintsNode.NodeAt(j);
if (clauseNode != null && clauseNode.NumValidNodes == 4)
{
var c = clauseNode.NodeAt(1);
if (c != null && c.NumValidNodes == 1)
{
var id = DecodeId(c.LeafAt(0).token.text);
if (id == name)
{
break;
}
}
}
clauseNode = null;
}
}
break;
}
}
}
if (clauseNode != null)
{
var constrantListNode = clauseNode.NodeAt(3);
if (constrantListNode != null)
{
var secondaryList = constrantListNode.NodeAt(-1);
if (secondaryList != null && secondaryList.RuleName == "secondaryConstraintList")
{
for (int i = 0; i < secondaryList.NumValidNodes; i += 2)
{
var constraintNode = secondaryList.NodeAt(i);
if (constraintNode != null)
{
var typeNameNode = constraintNode.NodeAt(0);
if (typeNameNode != null)
{
if (baseTypeConstraint == null && interfacesConstraint.Count == 0)
{
var resolvedType = ResolveNode(typeNameNode, null, null, 0, true) as TypeDefinitionBase;
if (resolvedType != null && resolvedType.kind != SymbolKind.Error)
{
if (resolvedType.kind == SymbolKind.Interface)
{
interfacesConstraint.Add(new SymbolReference(typeNameNode));
}
else
{
baseTypeConstraint = new SymbolReference(typeNameNode);
}
}
}
else
{
interfacesConstraint.Add(new SymbolReference(typeNameNode));
}
}
}
}
}
}
}
}
var result = baseTypeConstraint != null ? baseTypeConstraint.Definition as TypeDefinitionBase : base.BaseType();
if (result == this)
{
baseTypeConstraint = new SymbolReference(circularBaseType);
result = circularBaseType;
}
resolvingBaseType = false;
return(result);
}
public override void OnSemanticNodeClose(SyntaxTreeNode_Rule node)
{
m_kParser.OnSemanticNodeClose(this, node);
}
public Scope_MemberInitializer(SyntaxTreeNode_Rule node) : base(node)
{
}
public Scope_AccessorBody(SyntaxTreeNode_Rule node) : base(node)
{
}
public SyntaxTreeNode_Rule AddNode(ParseNode_Id rule, SyntaxTreeBuilder pSyntaxTreeBuilder, out bool skipParsing)
{
skipParsing = false;
bool removedReusable = false;
if (NumValidNodes < nodes.Count)
{
var reusable = nodes[NumValidNodes] as SyntaxTreeNode_Rule;
if (reusable != null)
{
var firstLeaf = reusable.GetFirstLeaf(false);
if (reusable.ParseNode != rule)
{
if (firstLeaf == null || firstLeaf.token == null || firstLeaf.Line <= pSyntaxTreeBuilder.TokenScanner.CurrentLine)
{
reusable.Dispose();
removedReusable = true;
}
}
else
{
if (firstLeaf != null && firstLeaf.token != null && firstLeaf.Line > pSyntaxTreeBuilder.TokenScanner.CurrentLine)
{
// Ignore this node for now
}
else if (firstLeaf == null || firstLeaf.token != null && firstLeaf.m_sSyntaxError != null)
{
reusable.Dispose();
removedReusable = true;
}
else if (firstLeaf.token == pSyntaxTreeBuilder.TokenScanner.Current)
{
var lastLeaf = reusable.GetLastLeaf();
if (lastLeaf != null && !reusable.HasErrors())
{
if (lastLeaf.token != null)
{
((SyntaxTreeBuilder_CSharp)pSyntaxTreeBuilder).MoveAfterLeaf(lastLeaf);
skipParsing = true;
++NumValidNodes;
return(pSyntaxTreeBuilder.SyntaxRule_Cur);
}
}
else
{
reusable.Dispose();
removedReusable = true;
}
}
else if (reusable.NumValidNodes == 0)
{
++NumValidNodes;
reusable.m_sSyntaxError = null;
reusable.m_bMissing = false;
return(reusable);
}
else if (pSyntaxTreeBuilder.TokenScanner.Current != null && (firstLeaf.token == null || firstLeaf.Line <= pSyntaxTreeBuilder.TokenScanner.CurrentLine))
{
reusable.Dispose();
if (firstLeaf.token == null || firstLeaf.Line == pSyntaxTreeBuilder.TokenScanner.CurrentLine)
{
removedReusable = true;
}
else
{
nodes.RemoveAt(NumValidNodes);
for (var i = NumValidNodes; i < nodes.Count; ++i)
{
--nodes[i].m_iChildIndex;
}
return(AddNode(rule, pSyntaxTreeBuilder, out skipParsing));
}
}
}
}
}
var node = new SyntaxTreeNode_Rule(rule)
{
Parent = this, m_iChildIndex = NumValidNodes
};
if (NumValidNodes == nodes.Count)
{
nodes.Add(node);
++NumValidNodes;
}
else
{
if (removedReusable)
{
nodes[NumValidNodes] = node;
}
else
{
nodes.Insert(NumValidNodes, node);
}
++NumValidNodes;
}
if (NumValidNodes < nodes.Count && nodes[NumValidNodes].m_iChildIndex != NumValidNodes)
{
for (var i = NumValidNodes; i < nodes.Count; ++i)
{
nodes[i].m_iChildIndex = i;
}
}
return(node);
}
public Scope_Body(SyntaxTreeNode_Rule node) : base(node)
{
}
public static int ProcessArgumentListNode(SyntaxTreeNode_Rule argumentListNode, out Modifiers[] modifiers, out List <TypeDefinitionBase> argumentTypes, TypeDefinitionBase extendedType)
{
var numArguments = argumentListNode == null ? 0 : (argumentListNode.NumValidNodes + 1) / 2;
var thisOffest = 0;
if (extendedType != null)
{
thisOffest = 1;
++numArguments;
}
modifiers = new Modifiers[numArguments];
argumentTypes = new List <TypeDefinitionBase>();
var resolvedArguments = new SymbolDefinition[numArguments];
if (extendedType != null)
{
argumentTypes.Add(extendedType);
}
for (var i = thisOffest; i < numArguments; ++i)
{
var argumentNode = argumentListNode.NodeAt((i - thisOffest) * 2);
if (argumentNode != null)
{
var argumentValueNode = argumentNode.FindChildByName("argumentValue") as SyntaxTreeNode_Rule;
if (argumentValueNode != null)
{
resolvedArguments[i] = ResolveNode(argumentValueNode);
if (resolvedArguments[i] != null)
{
argumentTypes.Add(resolvedArguments[i].TypeOf() as TypeDefinitionBase ?? unknownType);
}
else
{
argumentTypes.Add(unknownType);
}
var modifierLeaf = argumentValueNode.LeafAt(0);
if (modifierLeaf != null)
{
if (modifierLeaf.IsLit("ref"))
{
modifiers[i] = Modifiers.Ref;
}
else if (modifierLeaf.IsLit("out"))
{
modifiers[i] = Modifiers.Out;
}
}
continue;
}
}
numArguments = i;
break;
}
return(numArguments);
}
public Scope_Attributes(SyntaxTreeNode_Rule node) : base(node)
{
}
public Scope_Namespace(SyntaxTreeNode_Rule node) : base(node)
{
}
public abstract void OnSemanticNodeClose(SyntaxTreeNode_Rule node);
public Scope_SymbolDeclaration(SyntaxTreeNode_Rule node) : base(node)
{
}
public override SymbolDefinition ResolveAsExtensionMethod(SyntaxTreeNode_Leaf invokedLeaf, SymbolDefinition invokedSymbol, TypeDefinitionBase memberOf, SyntaxTreeNode_Rule argumentListNode, SymbolReference[] typeArgs, Scope_Base context)
{
if (invokedLeaf == null && (invokedSymbol == null || invokedSymbol.kind == SymbolKind.Error))
{
return(null);
}
var id = invokedSymbol != null && invokedSymbol.kind != SymbolKind.Error ? invokedSymbol.name : invokedLeaf != null?SymbolDefinition.DecodeId(invokedLeaf.token.text) : "";
int numArguments = 1;
Modifiers[] modifiers = null;
List <TypeDefinitionBase> argumentTypes = null;
MethodDefinition firstAccessibleMethod = null;
var thisAssembly = GetAssembly();
var extensionsMethods = new HashSet <MethodDefinition>();
thisAssembly.CollectExtensionMethods(definition, id, typeArgs, memberOf, extensionsMethods, context);
if (extensionsMethods.Count > 0)
{
firstAccessibleMethod = extensionsMethods.First();
if (argumentTypes == null)
{
numArguments = SD_MethodGroup.ProcessArgumentListNode(argumentListNode, out modifiers, out argumentTypes, memberOf);
}
var candidates = new List <MethodDefinition>(extensionsMethods.Count);
foreach (var method in extensionsMethods)
{
if (argumentTypes == null || method.CanCallWith(modifiers, true))
{
candidates.Add(method);
}
}
if (typeArgs == null)
{
for (var i = candidates.Count; i-- > 0;)
{
var candidate = candidates[i];
if (candidate.NumTypeParameters == 0 || argumentTypes == null)
{
continue;
}
candidate = SD_MethodGroup.InferMethodTypeArguments(candidate, argumentTypes, invokedLeaf);
if (candidate == null)
{
candidates.RemoveAt(i);
}
else
{
candidates[i] = candidate;
}
}
}
var resolved = SD_MethodGroup.ResolveMethodOverloads(numArguments, argumentTypes, modifiers, candidates);
if (resolved != null && resolved.kind != SymbolKind.Error)
{
return(resolved);
}
}
extensionsMethods.Clear();
var importedNamespaces = declaration.importedNamespaces;
for (var i = importedNamespaces.Count; i-- > 0;)
{
var nsDef = importedNamespaces[i].Definition as SD_NameSpace;
if (nsDef != null)
{
thisAssembly.CollectExtensionMethods(nsDef, id, typeArgs, memberOf, extensionsMethods, context);
}
}
if (extensionsMethods.Count > 0)
{
if (firstAccessibleMethod == null)
{
firstAccessibleMethod = extensionsMethods.First();
}
if (argumentTypes == null)
{
numArguments = SD_MethodGroup.ProcessArgumentListNode(argumentListNode, out modifiers, out argumentTypes, memberOf);
}
var candidates = new List <MethodDefinition>(extensionsMethods.Count);
foreach (var method in extensionsMethods)
{
if (argumentTypes == null || method.CanCallWith(modifiers, true))
{
candidates.Add(method);
}
}
if (typeArgs == null)
{
for (var i = candidates.Count; i-- > 0;)
{
var candidate = candidates[i];
if (candidate.NumTypeParameters == 0 || argumentTypes == null)
{
continue;
}
candidate = SD_MethodGroup.InferMethodTypeArguments(candidate, argumentTypes, invokedLeaf);
if (candidate == null)
{
candidates.RemoveAt(i);
}
else
{
candidates[i] = candidate;
}
}
}
var resolved = SD_MethodGroup.ResolveMethodOverloads(numArguments, argumentTypes, modifiers, candidates);
if (resolved != null && resolved.kind != SymbolKind.Error)
{
return(resolved);
}
}
if (parentScope != null)
{
var resolved = parentScope.ResolveAsExtensionMethod(invokedLeaf, invokedSymbol, memberOf, argumentListNode, typeArgs, context);
if (resolved != null)
{
return(resolved);
}
}
if (firstAccessibleMethod != null)
{
invokedLeaf.ResolvedSymbol = firstAccessibleMethod;
invokedLeaf.m_sSemanticError = SD_MethodGroup.unresolvedMethodOverload.name;
}
return(null);
}
public Scope_Local(SyntaxTreeNode_Rule node) : base(node)
{
}
public Scope_Base(SyntaxTreeNode_Rule node)
{
parseTreeNode = node;
}
public Scope_TypeBase(SyntaxTreeNode_Rule node) : base(node)
{
}
public virtual SymbolDefinition ResolveAsExtensionMethod(SyntaxTreeNode_Leaf invokedLeaf, SymbolDefinition invokedSymbol, TypeDefinitionBase memberOf, SyntaxTreeNode_Rule argumentListNode, SymbolReference[] typeArgs, Scope_Base context)
{
return(parentScope != null?parentScope.ResolveAsExtensionMethod(invokedLeaf, invokedSymbol, memberOf, argumentListNode, typeArgs, context) : null);
}
