public SyntaxTreeNode_Leaf AddToken(TokenScanner pTokenScanner)
{
if (NumValidNodes < nodes.Count)
{
var reused = nodes[NumValidNodes] as SyntaxTreeNode_Leaf;
if (reused != null && reused.TryReuse(pTokenScanner))
{
++NumValidNodes;
return(reused);
}
}
var leaf = new SyntaxTreeNode_Leaf(pTokenScanner)
{
Parent = this, m_iChildIndex = NumValidNodes
};
if (NumValidNodes == nodes.Count)
{
nodes.Add(leaf);
++NumValidNodes;
}
else
{
nodes.Insert(NumValidNodes++, leaf);
for (var i = NumValidNodes; i < nodes.Count; ++i)
{
++nodes[i].m_iChildIndex;
}
}
return(leaf);
}
public override void ResolveMember(SyntaxTreeNode_Leaf leaf, Scope_Base context, int numTypeArgs, bool asTypeOnly)
{
base.ResolveMember(leaf, context, numTypeArgs, asTypeOnly);
if (!resolvingInBase && leaf.ResolvedSymbol == null)
{
resolvingInBase = true;
var baseType = BaseType();
var interfaces = Interfaces();
if (!asTypeOnly && interfaces != null && (kind == SymbolKind.Interface || kind == SymbolKind.TypeParameter))
{
foreach (var i in interfaces)
{
i.Definition.ResolveMember(leaf, context, numTypeArgs, asTypeOnly);
if (leaf.ResolvedSymbol != null)
{
resolvingInBase = false;
return;
}
}
}
if (baseType != null && baseType != this)
{
baseType.ResolveMember(leaf, context, numTypeArgs, asTypeOnly);
}
resolvingInBase = false;
}
}
public override void ResolveMember(SyntaxTreeNode_Leaf leaf, Scope_Base context, int numTypeArgs, bool asTypeOnly)
{
genericTypeDefinition.ResolveMember(leaf, context, numTypeArgs, asTypeOnly);
var genericMember = leaf.ResolvedSymbol;
if (genericMember == null)// || genericMember is MethodGroupDefinition)// !genericMember.IsGeneric)
{
return;
}
SymbolDefinition constructed;
if (constructedMembers != null && constructedMembers.TryGetValue(genericMember, out constructed))
{
leaf.ResolvedSymbol = constructed;
}
else
{
leaf.ResolvedSymbol = GetConstructedMember(genericMember);
}
if (asTypeOnly && !(leaf.ResolvedSymbol is TypeDefinitionBase))
{
leaf.ResolvedSymbol = null;
}
}
public override void Resolve(SyntaxTreeNode_Leaf leaf, int numTypeArgs, bool asTypeOnly)
{
if (declaration != null && declaration.definition != null)
{
declaration.definition.ResolveMember(leaf, this, numTypeArgs, asTypeOnly);
if (numTypeArgs == 0 && leaf.ResolvedSymbol == null)
{
var typeParams = declaration.definition.GetTypeParameters();
if (typeParams != null)
{
var id = SymbolDefinition.DecodeId(leaf.token.text);
for (int i = typeParams.Count; i-- > 0;)
{
if (typeParams[i].GetName() == id)
{
leaf.ResolvedSymbol = typeParams[i];
break;
}
}
}
}
}
if (leaf.ResolvedSymbol == null)
{
base.Resolve(leaf, numTypeArgs, asTypeOnly);
}
}
public override void Resolve(SyntaxTreeNode_Leaf leaf, int numTypeArgs, bool asTypeOnly)
{
if (parentScope != null)
{
parentScope.Resolve(leaf, numTypeArgs, asTypeOnly);
}
}
public override void Resolve(SyntaxTreeNode_Leaf leaf, int numTypeArgs, bool asTypeOnly)
{
leaf.ResolvedSymbol = null;
var id = SymbolDefinition.DecodeId(leaf.token.text);
for (int i = declaration.typeAliases.Count; i-- > 0;)
{
if (declaration.typeAliases[i].name == id)
{
if (declaration.typeAliases[i].type != null)
{
leaf.ResolvedSymbol = declaration.typeAliases[i].type.Definition;
return;
}
else
{
break;
}
}
}
if (leaf.ResolvedSymbol == null)
{
for (var i = declaration.importedNamespaces.Count; i-- > 0;)
{
var nsRef = declaration.importedNamespaces[i];
if (nsRef.IsBefore(leaf) && nsRef.Definition != null)
{
nsRef.Definition.ResolveMember(leaf, this, numTypeArgs, true);
if (leaf.ResolvedSymbol != null)
{
if (leaf.ResolvedSymbol.kind == SymbolKind.Namespace)
{
leaf.ResolvedSymbol = null;
}
else
{
break;
}
}
}
}
}
var parentScopeDef = parentScope != null ? ((Scope_Namespace)parentScope).definition : null;
for (var nsDef = definition;
leaf.ResolvedSymbol == null && nsDef != null && nsDef != parentScopeDef;
nsDef = nsDef.parentSymbol as SD_NameSpace)
{
nsDef.ResolveMember(leaf, this, numTypeArgs, true);
}
if (leaf.ResolvedSymbol == null && parentScope != null)
{
parentScope.Resolve(leaf, numTypeArgs, true);
}
}
public virtual void Resolve(SyntaxTreeNode_Leaf leaf, int numTypeArgs, bool asTypeOnly)
{
leaf.ResolvedSymbol = null;
if (parentScope != null)
{
parentScope.Resolve(leaf, numTypeArgs, asTypeOnly);
}
}
public virtual void ResolveAttribute(SyntaxTreeNode_Leaf leaf)
{
leaf.ResolvedSymbol = null;
if (parentScope != null)
{
parentScope.ResolveAttribute(leaf);
}
}
public LexerToken(Kind kind, string text)
{
m_kLinkedLeaf = null;
tokenKind = kind;
this.text = string.Intern(text);
tokenId = -1;
style = null;
}
public override void ResolveMember(SyntaxTreeNode_Leaf leaf, Scope_Base context, int numTypeArgs, bool asTypeOnly)
{
var symbolType = TypeOf() as TypeDefinitionBase;
if (symbolType != null)
{
symbolType.ResolveMember(leaf, context, numTypeArgs, asTypeOnly);
}
}
public override void Resolve(SyntaxTreeNode_Leaf leaf, int numTypeArgs, bool asTypeOnly)
{
if (!asTypeOnly && numTypeArgs == 0 && leaf.token.text == "value" && definition.name != "get")
{
leaf.ResolvedSymbol = Value;
return;
}
base.Resolve(leaf, numTypeArgs, asTypeOnly);
}
public override void ResolveAttribute(SyntaxTreeNode_Leaf leaf)
{
if (declaration != null)
{
declaration.definition.ResolveAttributeMember(leaf, this);
}
if (leaf.ResolvedSymbol == null)
{
base.ResolveAttribute(leaf);
}
}
public bool IsBefore(SyntaxTreeNode_Leaf leaf)
{
if (parseTreeNode == null)
{
return(true);
}
var lastLeaf = parseTreeNode as SyntaxTreeNode_Leaf;
if (lastLeaf == null)
{
lastLeaf = ((SyntaxTreeNode_Rule)parseTreeNode).GetLastLeaf();
}
return(lastLeaf != null && (lastLeaf.Line < leaf.Line || lastLeaf.Line == leaf.Line && lastLeaf.TokenIndex < leaf.TokenIndex));
}
public SymbolDefinition ResolveParameterName(SyntaxTreeNode_Leaf leaf)
{
foreach (var m in methods)
{
var p = m.GetParameters();
var leafText = DecodeId(leaf.token.text);
var x = p.Find(pd => pd.name == leafText);
if (x != null)
{
return(leaf.ResolvedSymbol = x);
}
}
return(unknownSymbol);
}
public override void ResolveMember(SyntaxTreeNode_Leaf leaf, Scope_Base context, int numTypeArgs, bool asTypeOnly)
{
if (!asTypeOnly && parameters != null)
{
var leafText = DecodeId(leaf.token.text);
var definition = parameters.Find(x => x.name == leafText);
if (definition != null)
{
leaf.ResolvedSymbol = definition;
return;
}
}
base.ResolveMember(leaf, context, numTypeArgs, asTypeOnly);
}
public override void ResolveMember(SyntaxTreeNode_Leaf leaf, Scope_Base context, int numTypeArgs, bool asTypeOnly)
{
if (asTypeOnly)
{
leaf.ResolvedSymbol = null;
return;
}
TypeOf();
if (type == null || type.Definition == null || type.Definition == unknownType || type.Definition == unknownSymbol)
{
leaf.ResolvedSymbol = null;
return;
}
type.Definition.ResolveMember(leaf, context, numTypeArgs, false);
}
public void ResolveInReferencedAssemblies(SyntaxTreeNode_Leaf leaf, SD_NameSpace namespaceDefinition, int numTypeArgs)
{
var leafText = DecodeId(leaf.token.text);
foreach (var ra in referencedAssemblies)
{
var nsDef = ra.FindSameNamespace(namespaceDefinition);
if (nsDef != null)
{
leaf.ResolvedSymbol = nsDef.FindName(leafText, numTypeArgs, true);
if (leaf.ResolvedSymbol != null)
{
return;
}
}
}
}
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 Resolve(SyntaxTreeNode_Leaf leaf, int numTypeArgs, bool asTypeOnly)
{
leaf.ResolvedSymbol = null;
base.Resolve(leaf, numTypeArgs, asTypeOnly);
if (leaf.ResolvedSymbol == null || leaf.ResolvedSymbol == SymbolDefinition.unknownSymbol)
{
if (leaf.Parent.RuleName == "typeOrGeneric" && leaf.Parent.Parent.Parent.Parent.RuleName == "attribute" &&
leaf.Parent.m_iChildIndex == leaf.Parent.Parent.NumValidNodes - 1)
{
var old = leaf.token.text;
leaf.token.text += "Attribute";
leaf.ResolvedSymbol = null;
base.Resolve(leaf, numTypeArgs, true);
leaf.token.text = old;
}
}
}
public override void Resolve(SyntaxTreeNode_Leaf leaf, int numTypeArgs, bool asTypeOnly)
{
leaf.ResolvedSymbol = null;
if (!asTypeOnly && localSymbols != null)
{
var id = SymbolDefinition.DecodeId(leaf.token.text);
for (var i = localSymbols.Count; i-- > 0;)
{
if (localSymbols[i].name == id)
{
leaf.ResolvedSymbol = localSymbols[i];
return;
}
}
}
base.Resolve(leaf, numTypeArgs, asTypeOnly);
}
public override void ResolveAttributeMember(SyntaxTreeNode_Leaf leaf, Scope_Base context)
{
if (resolvingMember)
{
return;
}
resolvingMember = true;
leaf.ResolvedSymbol = null;
base.ResolveAttributeMember(leaf, context);
resolvingMember = false;
if (leaf.ResolvedSymbol == null)
{
var assemblyDefinition = context.GetAssembly();
assemblyDefinition.ResolveAttributeInReferencedAssemblies(leaf, this);
}
}
public bool MoveAfterLeaf(SyntaxTreeNode_Leaf leaf)
{
if (leaf == null || leaf.ParseNode == null)
{
return(false);
}
if (leaf.m_sSyntaxError != null)
{
Debug.LogError("Can't move after error node! " + leaf.m_sSyntaxError);
return(false);
}
var parseTreeNode = leaf.Parent;
if (parseTreeNode == null)
{
return(false);
}
SyntaxRule_Cur = null;
ParseNode_Cur = null;
ErrorToken = null;
ErrorMessage = null;
SyntaxRule_Err = null;
ParseNode_Err = null;
//tokens = lines[leaf.Line].tokens;
//currentLine = leaf.Line;
//currentTokenIndex = leaf.TokenIndex;
m_kTokenScanner.MoveTo(leaf.Line, leaf.TokenIndex);
m_kTokenScanner.MoveNext();
SyntaxRule_Cur = leaf.Parent;
ErrorMessage = null;
Seeking = true;
ParseNode_Err = ParseNode_Cur = leaf.ParseNode.parent.NextAfterChild(leaf.ParseNode, this);
Seeking = false;
SyntaxRule_Err = SyntaxRule_Cur;
return(true);
}
public override void ResolveMember(SyntaxTreeNode_Leaf leaf, Scope_Base context, int numTypeArgs, bool asTypeOnly)
{
if (!allPublicMembersReflected)
{
if (!allNonPublicMembersReflected)
{
ReflectAllMembers(BindingFlags.Public | BindingFlags.NonPublic);
}
else
{
ReflectAllMembers(BindingFlags.Public);
}
}
else if (!allNonPublicMembersReflected)
{
ReflectAllMembers(BindingFlags.NonPublic);
}
base.ResolveMember(leaf, context, numTypeArgs, asTypeOnly);
}
public SyntaxTreeNode_Leaf AddToken(LexerToken token)
{
if (!token.IsMissing() && NumValidNodes < nodes.Count)
{
var reused = nodes[NumValidNodes] as SyntaxTreeNode_Leaf;
if (reused != null && reused.token.text == token.text && reused.token.tokenKind == token.tokenKind)
{
reused.m_bMissing = false;
reused.m_sSyntaxError = null;
reused.token = token;
reused.Parent = this;
reused.m_iChildIndex = NumValidNodes;
++NumValidNodes;
Debug.Log("reused " + reused.token + " from line " + (reused.Line + 1));
return(reused);
}
}
var leaf = new SyntaxTreeNode_Leaf {
token = token, Parent = this, m_iChildIndex = NumValidNodes
};
if (NumValidNodes == nodes.Count)
{
nodes.Add(leaf);
++NumValidNodes;
}
else
{
nodes.Insert(NumValidNodes++, leaf);
for (var i = NumValidNodes; i < nodes.Count; ++i)
{
++nodes[i].m_iChildIndex;
}
}
return(leaf);
}
public override void ResolveMember(SyntaxTreeNode_Leaf leaf, Scope_Base context, int numTypeArgs, bool asTypeOnly)
{
if (asTypeOnly)
{
return;
}
if (numTypeArgs == 0)
{
var leafText = DecodeId(leaf.token.text);
if (parameters != null)
{
for (var i = parameters.Count; i-- > 0;)
{
if (parameters[i].name == leafText)
{
leaf.ResolvedSymbol = parameters[i];
return;
}
}
}
if (typeParameters != null)
{
for (var i = typeParameters.Count; i-- > 0;)
{
if (typeParameters[i].name == leafText)
{
leaf.ResolvedSymbol = typeParameters[i];
return;
}
}
}
}
base.ResolveMember(leaf, context, numTypeArgs, asTypeOnly);
}
public override void ResolveMember(SyntaxTreeNode_Leaf leaf, Scope_Base context, int numTypeArgs, bool asTypeOnly)
{
if (resolvingMember)
{
return;
}
resolvingMember = true;
leaf.ResolvedSymbol = null;
base.ResolveMember(leaf, context, numTypeArgs, asTypeOnly);
resolvingMember = false;
if (leaf.ResolvedSymbol == null)
{
if (context != null)
{
var assemblyDefinition = context.GetAssembly();
assemblyDefinition.ResolveInReferencedAssemblies(leaf, this, numTypeArgs);
}
}
}
private SymbolReference TypeOfImplicitParameter(SymbolDeclaration declaration)
{
int index = 0;
var node = declaration.parseTreeNode;
if (node.Parent.RuleName == "implicitAnonymousFunctionParameterList")
{
index = node.m_iChildIndex / 2;
node = node.Parent;
}
node = node.Parent; // anonymousFunctionSignature
node = node.Parent; // lambdaExpression
node = node.Parent; // nonAssignmentExpression
node = node.Parent; // elementInitializer or expression
if (node.RuleName == "elementInitializer")
{
node = node.Parent // elementInitializerList
.Parent // collectionInitializer
.Parent // objectOrCollectionInitializer
.Parent // objectCreationExpression
.Parent; // primaryExpression
if (node.RuleName != "primaryExpression")
{
return(null);
}
node = node.NodeAt(1);
if (node == null || node.RuleName != "nonArrayType")
{
return(null);
}
var collectionType = ResolveNode(node.ChildAt(0)).TypeOf() as TypeDefinitionBase;
if (collectionType != null && collectionType.kind != SymbolKind.Error)
{
var enumerableType = collectionType.ConvertTo(builtInTypes_IEnumerable_1) as SD_Type_Constructed;
var targetTypeReference = enumerableType == null || enumerableType.typeArguments == null ? null : enumerableType.typeArguments.FirstOrDefault();
var targetType = targetTypeReference == null ? null : targetTypeReference.Definition;
if (targetType != null && targetType.kind == SymbolKind.Delegate)
{
var delegateParameters = targetType.GetParameters();
if (delegateParameters != null && index < delegateParameters.Count)
{
var type = delegateParameters[index].TypeOf();
type = type.SubstituteTypeParameters(targetType);
return(new SymbolReference(type));
}
}
}
}
if (node.RuleName == "expression" && (node.Parent.RuleName == "localVariableInitializer" || node.Parent.RuleName == "variableInitializer"))
{
node = node.Parent.Parent;
if (node.RuleName == "variableInitializerList")
{
node = node.Parent.Parent.Parent.NodeAt(1);
if (node == null || node.RuleName != "nonArrayType")
{
return(null);
}
}
else if (node.RuleName != "localVariableDeclarator" && node.RuleName != "variableDeclarator")
{
return(null);
}
var targetSymbol = node.ChildAt(0).ResolvedSymbol ?? ResolveNode(node.ChildAt(0));
if (targetSymbol != null && targetSymbol.kind != SymbolKind.Error)
{
var targetType = targetSymbol.kind == SymbolKind.Delegate ? targetSymbol : targetSymbol.TypeOf();
if (targetType != null && targetType.kind == SymbolKind.Delegate)
{
var delegateParameters = targetType.GetParameters();
if (delegateParameters != null && index < delegateParameters.Count)
{
var type = delegateParameters[index].TypeOf();
type = type.SubstituteTypeParameters(targetType);
return(new SymbolReference(type));
}
}
}
}
else if (node.RuleName == "expression" && node.Parent.RuleName == "argumentValue")
{
node = node.Parent; // argumentValue
if (node.m_iChildIndex == 0)
{
node = node.Parent; // argument
var argumentIndex = node.m_iChildIndex / 2;
node = node.Parent; // argumentList
node = node.Parent; // arguments
node = node.Parent; // constructorInitializer or attribute or primaryExpressionPart or objectCreationExpression
if (node.RuleName == "primaryExpressionPart")
{
SyntaxTreeNode_Leaf methodId = null;
node = node.Parent.NodeAt(node.m_iChildIndex - 1); // primaryExpressionStart or primaryExpressionPart
if (node.RuleName == "primaryExpressionStart")
{
methodId = node.LeafAt(0);
}
else // node.RuleName == "primaryExpressionPart"
{
node = node.NodeAt(0);
if (node.RuleName == "accessIdentifier")
{
methodId = node.LeafAt(1);
}
}
if (methodId != null && methodId.token.tokenKind == LexerToken.Kind.Identifier)
{
if (methodId.ResolvedSymbol == null || methodId.ResolvedSymbol.kind == SymbolKind.MethodGroup)
{
SymbolResolver.ResolveNode(node);
}
var method = methodId.ResolvedSymbol as MethodDefinition;
var constructedSymbol = methodId.ResolvedSymbol as SD_ConstructedReference;
if (method != null)
{
if (method.IsExtensionMethod)
{
var nodeLeft = methodId.Parent;
if (nodeLeft != null && nodeLeft.RuleName == "accessIdentifier")
{
nodeLeft = nodeLeft.FindPreviousNode() as SyntaxTreeNode_Rule;
if (nodeLeft != null)
{
if (nodeLeft.RuleName == "primaryExpressionPart" || nodeLeft.RuleName == "primaryExpressionStart")
{
var symbolLeft = SymbolResolver.GetResolvedSymbol(nodeLeft);
if (symbolLeft != null && symbolLeft.kind != SymbolKind.Error && !(symbolLeft is TypeDefinitionBase))
{
++argumentIndex;
}
}
else
{
++argumentIndex;
}
}
}
}
if (argumentIndex < method.parameters.Count)
{
var parameter = method.parameters[argumentIndex];
var parameterType = parameter.TypeOf();
if (parameterType.kind == SymbolKind.Delegate)
{
parameterType = parameterType.SubstituteTypeParameters(method);
var delegateParameters = parameterType.GetParameters();
if (delegateParameters != null && index < delegateParameters.Count)
{
var type = delegateParameters[index].TypeOf();
type = type.SubstituteTypeParameters(parameterType);
//type = type.SubstituteTypeParameters(method);
return(new SymbolReference(type));
}
}
}
}
else if (constructedSymbol != null && constructedSymbol.kind == SymbolKind.Method)
{
var genericMethod = constructedSymbol.referencedSymbol;
var parameters = genericMethod.GetParameters();
if (parameters != null && argumentIndex < parameters.Count)
{
var parameter = parameters[argumentIndex];
var parameterType = parameter.TypeOf();
if (parameterType.kind == SymbolKind.Delegate)
{
parameterType = parameterType.SubstituteTypeParameters(constructedSymbol);
var delegateParameters = parameterType.GetParameters();
if (delegateParameters != null && index < delegateParameters.Count)
{
var type = delegateParameters[index].TypeOf();
type = type.SubstituteTypeParameters(parameterType);
//type = type.SubstituteTypeParameters(constructedSymbol);
return(new SymbolReference(type));
}
}
}
}
}
}
}
}
return(null);
}
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));
}
public override MethodDefinition ResolveMethodOverloads(List <TypeDefinitionBase> argumentTypes, Modifiers[] modifiers, Scope_Base scope, SyntaxTreeNode_Leaf invokedLeaf)
{
var genericMethods = genericMethodGroupDefinition.methods;
methods.RemoveWhere(m => !genericMethods.Contains(m.GetGenericSymbol() as MethodDefinition));
foreach (var m in genericMethods)
{
if (m.NumTypeParameters == typeArguments.Length && methods.All(method => method.GetGenericSymbol() != m))
{
var constructedMethod = m.ConstructMethod(typeArguments);
if (constructedMethod != null)
{
methods.Add(constructedMethod);
}
}
}
return(base.ResolveMethodOverloads(argumentTypes, modifiers, scope, invokedLeaf));
}
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);
}
