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); }