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