public static bool ScanForConstructors(NewExpression sr, IBlockNode scope, UserDefinedType udt, List <AbstractType> _ctors, out bool explicitCtorFound) { explicitCtorFound = false; var ct = new CtorScan(sr, new ResolutionContext(new Misc.ParseCacheView(new RootPackage[] {}), null, scope)); ct.DeepScanClass(udt, MemberFilter.Methods, false); _ctors.AddRange(ct.matches_types); var rawList = (udt.Definition as DClassLike)[DMethod.ConstructorIdentifierHash]; if (rawList != null) { foreach (var n in rawList) { var dm = n as DMethod; if (dm == null || dm.IsStatic || dm.SpecialType != DMethod.MethodType.Constructor) { continue; } explicitCtorFound = true; break; } } return(ct.matches_types.Count != 0); }
public CtrlSpaceCompletionProvider(ICompletionDataGenerator cdg, IBlockNode b, IStatement stmt, MemberFilter vis = MemberFilter.All) : base(cdg) { this.curBlock = b; this.curStmt = stmt; visibleMembers = vis; }
private static void HandleNewExpression_Ctor(NewExpression nex, IBlockNode curBlock, List <AbstractType> _ctors, AbstractType t) { var udt = t as TemplateIntermediateType; if (udt is ClassType || udt is StructType) { bool explicitCtorFound; if (!CtorScan.ScanForConstructors(nex, curBlock, udt, _ctors, out explicitCtorFound)) { if (explicitCtorFound) { // TODO: Somehow inform the user that the current class can't be instantiated } else { // Introduce default constructor _ctors.Add(new MemberSymbol(new DMethod(DMethod.MethodType.Constructor) { Description = "Default constructor for " + udt.Name, Parent = udt.Definition }, udt, nex)); } } } }
private ParameterInsightResolution(IEditorData ed, ResolutionContext c, ArgumentsResolutionResult r, IBlockNode cs) { Editor = ed; ctxt = c; res = r; curScope = cs; }
public static void EnumChildren(ICompletionDataGenerator cdgen,ResolutionContext ctxt, IBlockNode block, bool isVarInstance, MemberFilter vis = MemberFilter.Methods | MemberFilter.Types | MemberFilter.Variables | MemberFilter.Enums, bool publicImports = false) { var scan = new MemberCompletionEnumeration(ctxt, cdgen) { isVarInst = isVarInstance }; scan.ScanBlock(block, CodeLocation.Empty, vis, publicImports); }
static void BuildTreeChildren(TreeStore Tree, TreeIter ParentTreeNode, IBlockNode ParentAstNode) { if (ParentAstNode == null) { return; } foreach (var n in ParentAstNode) { if (!DCodeCompletionSupport.CanItemBeShownGenerally(n as DNode)) { continue; } TreeIter childIter; if (!ParentTreeNode.Equals(TreeIter.Zero)) { childIter = Tree.AppendValues(ParentTreeNode, n); } else { childIter = Tree.AppendValues(n); } BuildTreeChildren(Tree, childIter, n as IBlockNode); } }
public void Set(IBlockNode b) { scopedBlock = b; Caret = CodeLocation.Empty; ConditionalCompilation.EnumConditions(DeclarationCondititons, b, ctxt, CodeLocation.Empty); }
void CreateDeeperLevelCache(IBlockNode bn) { var dd = TypeCache[bn] = new Dictionary <string, INode>(); // Set the parent to null to crawl through current level only. Imports/Mixins etc. will be handled though. var parentBackup = bn.Parent; bn.Parent = null; sharedCtxt.CurrentContext.ScopedBlock = bn; var vis = ItemEnumeration.EnumAllAvailableMembers(sharedCtxt, bn.EndLocation, MemberFilter.Types); if (vis != null) { foreach (var n in vis) { if (!string.IsNullOrEmpty(n.Name)) { dd[n.Name] = n; } } } bn.Parent = parentBackup; }
/// <summary> /// Used for caching available types. /// </summary> protected override void OnScopedBlockChanged(IBlockNode bn) { Dictionary <int, byte> dd = null; foreach (var n in ItemEnumeration.EnumScopedBlockChildren(ctxt, MemberFilter.Types | MemberFilter.Enums)) { if (n.NameHash != 0) { if (dd == null && !TypeCache.TryGetValue(bn, out dd)) { TypeCache [bn] = dd = new Dictionary <int, byte> (); } byte type = 0; if (n is DClassLike) { type = (n as DClassLike).ClassType; } else if (n is DEnum) { type = DTokens.Enum; } else if (n is TemplateParameter.Node) { type = DTokens.Not; // Only needed for highlighting and thus just a convention question } dd[n.NameHash] = type; } } }
public void Set(IBlockNode b, CodeLocation caret) { scopedBlock = b; Caret = caret; ConditionalCompilation.EnumConditions(DeclarationCondititons, b, ctxt, caret); }
public virtual void VisitChildren(IBlockNode block) { foreach (var n in block) { n.Accept(this); } }
public MemberCompletionProvider(ICompletionDataGenerator cdg, ISyntaxRegion sr, IBlockNode b, IStatement stmt) : base(cdg) { AccessExpression = sr; ScopedBlock = b; ScopedStatement = stmt; }
public void Set(IBlockNode b) { scopedBlock = b; Caret = CodeLocation.Empty; ConditionalCompilation.EnumConditions(DeclarationCondititons, b, ctxt, CodeLocation.Empty); }
void GenerateFoldsInternal(List <FoldingRegion> l, IBlockNode block) { if (block != null) { block.Accept(new FoldingVisitor(l)); } }
public static ISyntaxRegion FindCurrentCaretContext(IEditorData editor, ref IBlockNode currentScope, out IStatement currentStatement, out bool isInsideNonCodeSegment) { isInsideNonCodeSegment = false; currentStatement = null; if(currentScope == null) currentScope = DResolver.SearchBlockAt (editor.SyntaxTree, editor.CaretLocation, out currentStatement); if (currentScope == null) return null; BlockStatement blockStmt; // Always skip lambdas as they're too quirky for accurate scope calculation // ISSUE: May be other anon symbols too? var dm = currentScope as DMethod; if (dm != null && (dm.SpecialType & DMethod.MethodType.Lambda) != 0) currentScope = dm.Parent as IBlockNode; if (currentScope is DMethod && (blockStmt = (currentScope as DMethod).GetSubBlockAt (editor.CaretLocation)) != null) { blockStmt.UpdateBlockPartly (editor, out isInsideNonCodeSegment); currentScope = DResolver.SearchBlockAt (currentScope, editor.CaretLocation, out currentStatement); }else { while (currentScope is DMethod) currentScope = currentScope.Parent as IBlockNode; if (currentScope == null) return null; (currentScope as DBlockNode).UpdateBlockPartly (editor, out isInsideNonCodeSegment); currentScope = DResolver.SearchBlockAt (currentScope, editor.CaretLocation, out currentStatement); } return currentScope; }
public void CreatePseudoAliases(IBlockNode Parent) { PseudoAliases.Clear(); foreach (var imp in Imports) { if (imp.ModuleAlias != null) { PseudoAliases.Add(new ModuleAliasNode(this, imp, Parent)); } } if (ImportBindList != null) { /* * import cv=std.conv : Convert = to; * * cv can be still used as an alias for std.conv, * whereas Convert is a direct alias for std.conv.to */ if (ImportBindList.Module.ModuleAlias != null) { PseudoAliases.Add(new ModuleAliasNode(this, ImportBindList.Module, Parent)); } foreach (var bind in ImportBindList.SelectedSymbols) { PseudoAliases.Add(new ImportSymbolAlias(this, bind, Parent)); } } }
public ContextFrame(ResolutionContext ctxt, IBlockNode b, IStatement stmt = null) { this.ctxt = ctxt; declarationCondititons = new ConditionalCompilation.ConditionSet(ctxt.CompilationEnvironment); Set(b,stmt); }
void SearchResultsIn(IBlockNode block, string pattern, List <INode> results, int maxResults) { // Don't search in modules themselves! if (block.Children.Count == 0 || results.Count > maxResults) { return; } foreach (var n in block.Children) { if (!results.Contains(n) && n.Name.Contains(pattern)) { if (!results.Contains(n)) { results.Add(n); } } if (n is IBlockNode) { SearchResultsIn(n as IBlockNode, pattern, results, maxResults); } if (results.Count > maxResults) { return; } } }
public static List <FoldingRange> GenerateFoldsInternal(IBlockNode block) { var l = new List <FoldingRange>(); block?.Accept(new FoldingVisitor(l)); return(l); }
public CtrlSpaceCompletionProvider(ICompletionDataGenerator cdg, IBlockNode b, IStatement stmt, MemberFilter vis = MemberFilter.All) : base(cdg) { this.curBlock = b; this.curStmt = stmt; visibleMembers = vis; }
public void Set(IBlockNode b, CodeLocation caret) { scopedBlock = b; Caret = caret; ConditionalCompilation.EnumConditions(DeclarationCondititons, b, ctxt, caret); }
public CtrlSpaceCompletionProvider(ICompletionDataGenerator cdg, IBlockNode b, MemberFilter vis = MemberFilter.All, params byte[] specialKeywords) : base(cdg) { this.curBlock = b; visibleMembers = vis; this.specialKeywords = specialKeywords; }
public ContextFrame(ResolutionContext ctxt, IBlockNode b, IStatement stmt = null) { this.ctxt = ctxt; declarationCondititons = new ConditionalCompilation.ConditionSet(ctxt.CompilationEnvironment); Set(b, stmt); }
public static void EnumConditions(ConditionSet cs, IBlockNode block, ResolutionContext ctxt, CodeLocation caret) { if (block != null && block.NodeRoot != null) { block.NodeRoot.Accept(new ConditionVisitor(cs, ctxt, caret)); } return; }
/// <summary>Gets the score of the best (first) node.</summary> public int GetScore(IBlockNode node) { if (Empty()) { return(Scores.Loses(node.Depth)); } return(this[0].Score); }
public static void RemoveDoubles(IBlockNode originalAst, IBlockNode blockToClean) { var rem = new DoubleDeclarationSilencer(); originalAst.Accept(rem); rem.secondRun = true; blockToClean.Accept(rem); }
public void ApplyFrom(ResolverContext other) { if (other == null) return; ScopedBlock = other.ScopedBlock; ScopedStatement = other.ScopedStatement; }
void GenerateFoldsInternal(List <FoldingRegion> l, IBlockNode block) { if (block == null) { return; } if (!(block is DModule) && !block.Location.IsEmpty && block.EndLocation > block.Location) { if (block is DMethod) { var dm = block as DMethod; if (dm.In != null) { GenerateFoldsInternal(l, dm.In); } if (dm.Out != null) { GenerateFoldsInternal(l, dm.Out); } if (dm.Body != null) { GenerateFoldsInternal(l, dm.Body); } } else { l.Add(new FoldingRegion(GetBlockBodyRegion(block), FoldType.Type)); } } if (block.Count > 0) { foreach (var n in block) { GenerateFoldsInternal(l, n as IBlockNode); } } if (block is DBlockNode) { var dbn = block as DBlockNode; if (dbn.MetaBlocks != null) { for (int i = dbn.MetaBlocks.Count - 1; i >= 0; i--) { var mdb = dbn.MetaBlocks[i] as IMetaDeclarationBlock; if (mdb != null) { l.Add(new FoldingRegion( new DomRegion(mdb.BlockStartLocation.Line, mdb.BlockStartLocation.Column, mdb.EndLocation.Line, mdb.EndLocation.Column), FoldType.Undefined)); } } } } }
public ContextFrame(ResolutionContext ctxt, IBlockNode b, CodeLocation caret) { this.ctxt = ctxt; DeclarationCondititons = new ConditionalCompilation.ConditionSet(ctxt.CompilationEnvironment); ctxt.Push(this); Set(b, caret); }
public static ISyntaxRegion FindCurrentCaretContext(IEditorData editor, ref IBlockNode currentScope, out bool isInsideNonCodeSegment) { isInsideNonCodeSegment = false; if (currentScope == null) { currentScope = DResolver.SearchBlockAt(editor.SyntaxTree, editor.CaretLocation); } if (currentScope == null) { return(null); } // class asd : | if (currentScope is IBlockNode && (currentScope as IBlockNode).BlockStartLocation > editor.CaretLocation) { currentScope = currentScope.Parent as IBlockNode; } BlockStatement blockStmt; // Always skip lambdas as they're too quirky for accurate scope calculation // ISSUE: May be other anon symbols too? var dm = currentScope as DMethod; if (dm != null && (dm.SpecialType & DMethod.MethodType.Lambda) != 0) { currentScope = dm.Parent as IBlockNode; } if (currentScope is DMethod && (blockStmt = (currentScope as DMethod).GetSubBlockAt(editor.CaretLocation)) != null) { var tempBlock = blockStmt.UpdateBlockPartly(editor, out isInsideNonCodeSegment); if (tempBlock == null) { return(null); } currentScope = DResolver.SearchBlockAt(tempBlock, editor.CaretLocation); } else { while (currentScope is DMethod) { currentScope = currentScope.Parent as IBlockNode; } if (currentScope == null) { return(null); } var tempBlock = (currentScope as DBlockNode).UpdateBlockPartly(editor, out isInsideNonCodeSegment); currentScope = DResolver.SearchBlockAt(tempBlock, editor.CaretLocation); } return(currentScope); }
public override void VisitChildren(IBlockNode block) { var ch = DResolver.SearchRegionAt <INode>(block.Children, caret); if (ch != null && ch != block) { ch.Accept(this); } }
public void ApplyFrom(ResolverContext other) { if (other == null) { return; } ScopedBlock = other.ScopedBlock; ScopedStatement = other.ScopedStatement; }
public ModuleAliasNode(ImportStatement impStmt, ImportStatement.Import imp, IBlockNode parentNode) : base(impStmt, parentNode) { this.Import = imp; Name = imp.ModuleAlias.Id; Location = NameLocation = imp.ModuleIdentifier.Location; Type = imp.ModuleIdentifier; }
public static BracketSearchResult SearchBrackets(TextDocument doc, IEditorData ed, IBlockNode curBlock, IStatement stmt) { while (stmt != null) { if (stmt is IExpressionContainingStatement) { var ecs = (IExpressionContainingStatement)stmt; foreach (var x in ecs.SubExpressions) { SurroundingParenthesesExpression spe = null; var xx = x; while (xx is ContainerExpression) { if (xx is SurroundingParenthesesExpression) spe = (SurroundingParenthesesExpression)xx; var subX = ((ContainerExpression)xx).SubExpressions; if (subX != null && subX.Length != 0) { xx = null; foreach (var sx in subX) if (ed.CaretLocation > sx.Location && ed.CaretLocation < sx.EndLocation) { xx = sx as ContainerExpression; break; } } } if (spe != null) return new BracketSearchResult( doc.GetOffset(spe.Location.Line, spe.Location.Column), 1, doc.GetOffset(spe.EndLocation.Line, spe.EndLocation.Column) - 1, 1); } } if (stmt is BlockStatement) return new BracketSearchResult( doc.GetOffset(stmt.Location.Line, stmt.Location.Column), 1, doc.GetOffset(stmt.EndLocation.Line, stmt.EndLocation.Column) - 1, 1); stmt = stmt.Parent; } if (curBlock != null && ed.CaretLocation < curBlock.BlockStartLocation) curBlock = curBlock.Parent as IBlockNode; if (curBlock == null || curBlock is DModule) return null; //TODO: Meta blocks, everything that could contain parentheses return new BracketSearchResult( doc.GetOffset(curBlock.BlockStartLocation.Line, curBlock.BlockStartLocation.Column), 1, doc.GetOffset(curBlock.EndLocation.Line, curBlock.EndLocation.Column) - 1, 1); }
public override void VisitChildren(IBlockNode block) { var b = scopedBlock; var s = scopedStatement; scopedStatement = null; scopedBlock = block; base.VisitChildren(block); scopedBlock = b; scopedStatement = s; }
public ResolverContext PushNewScope(IBlockNode scope) { var ctxtOverride = new ResolverContext(); ctxtOverride.ScopedBlock = scope; ctxtOverride.ScopedStatement = null; stack.Push(ctxtOverride); return(ctxtOverride); }
/// <summary> /// The execute transaction inner. /// </summary> /// <param name="solution"> /// The solution. /// </param> /// <param name="textControl"> /// The text control. /// </param> public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl) { Utils.FormatLineForTextControl(solution, textControl); IElement element = Utils.GetElementAtCaret(solution, textControl); IBlockNode containingBlock = element.GetContainingElement <IBlockNode>(true); if (containingBlock != null) { new SpacingRules().SingleLineCommentsMustBeginWithSingleSpace(element.ToTreeNode()); } }
/// <summary> /// The execute transaction inner. /// </summary> /// <param name="solution"> /// The solution. /// </param> /// <param name="textControl"> /// The text control. /// </param> public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl) { Utils.FormatLineForTextControl(solution, textControl); IElement element = Utils.GetElementAtCaret(solution, textControl); IBlockNode containingBlock = element.GetContainingElement <IBlockNode>(true); if (containingBlock != null) { new SpacingRules().CodeMustNotContainMultipleWhitespaceInARow(element.ToTreeNode()); } }
public override IEnumerable <INode> PrefilterSubnodes(IBlockNode bn) { if (bn is DModule) { if (nameFilterHash == 0) { return(bn.Children); } return(bn [nameFilterHash]); } return(null); }
public static void EnumAllAvailableMembers(ICompletionDataGenerator cdgen, IBlockNode ScopedBlock , IStatement ScopedStatement, CodeLocation Caret, ParseCacheView CodeCache, MemberFilter VisibleMembers, ConditionalCompilationFlags compilationEnvironment = null) { var ctxt = ResolutionContext.Create(CodeCache, compilationEnvironment, ScopedBlock, ScopedStatement); var en = new MemberCompletionEnumeration(ctxt, cdgen) {isVarInst = true}; en.IterateThroughScopeLayers(Caret, VisibleMembers); }
public static IEnumerable<INode> EnumAllAvailableMembers(IBlockNode ScopedBlock , IStatement ScopedStatement, CodeLocation Caret, ParseCacheList CodeCache, MemberFilter VisibleMembers) { return EnumAllAvailableMembers(new ResolverContextStack(CodeCache,new ResolverContext { ScopedBlock = ScopedBlock, ScopedStatement = ScopedStatement }), Caret, VisibleMembers); }
public void BeginUpdate() { if (hasBegun) return; hasBegun = true; currentCol = Document.Editor.Caret.Column; currentLine = Document.Editor.Caret.Line; var caret = new CodeLocation(currentCol, currentLine); currentBlock = DResolver.SearchBlockAt(Ast, caret, out currentStmt); isBeforeBlockStart = currentBlock != null && caret <= currentBlock.BlockStartLocation; isAtStmtStart = currentStmt != null && caret == currentStmt.Location; }
public static void EnumConditions(ConditionSet cs,IStatement stmt, IBlockNode block, ResolutionContext ctxt, CodeLocation caret) { var l = new MutableConditionFlagSet(); cs.LocalFlags = l; // If the current scope is a dedicated block.. (so NOT in a method but probably in an initializer or other static statement) if(block is DBlockNode) { // If so, get all (scoping) declaration conditions in the current block // and add them to the condition list var mblocks = ((DBlockNode)block).GetMetaBlockStack(caret, false, true); if(mblocks!=null && mblocks.Length!=0) foreach(var mb in mblocks) { var amd = mb as AttributeMetaDeclaration; if(amd!=null && amd.AttributeOrCondition!=null && amd.AttributeOrCondition.Length!=0) foreach(var attr in amd.AttributeOrCondition) if(attr is DeclarationCondition) l.Add((DeclarationCondition)attr); } } // Scan up the current statement when e.g. inside a method body while (stmt != null) { if (stmt is StatementCondition) l.Add(((StatementCondition)stmt).Condition); stmt = stmt.Parent; } // Go up the block hierarchy and add all conditions that belong to the respective nodes while (block != null) { var dn = block as DNode; if (dn!=null) { if(dn is DBlockNode) GetDoneVersionDebugSpecs(cs, l, dn as DBlockNode, ctxt); if(dn.Attributes!=null) foreach (var attr in dn.Attributes) if (attr is DeclarationCondition) l.Add(((DeclarationCondition)attr)); } block = block.Parent as IBlockNode; } }
public void Set(IBlockNode b, IStatement stmt = null) { scopedBlock = b; scopedStmt = stmt; var c = CodeLocation.Empty; //TODO: Take the caret position if we're in the currently edited module and the scoped block is the module root(?) if(stmt == null) { if(b!=null) c = b.BlockStartLocation; } else c = stmt.Location; ConditionalCompilation.EnumConditions(declarationCondititons, stmt, b, ctxt, c); }
void CreateDeeperLevelCache(IBlockNode bn) { var dd = TypeCache[bn] = new Dictionary<int,INode>(); // Set the parent to null to crawl through current level only. Imports/Mixins etc. will be handled though. var parentBackup = bn.Parent; bn.Parent = null; sharedCtxt.CurrentContext.Set(bn); foreach (var n in ItemEnumeration.EnumScopedBlockChildren(sharedCtxt, MemberFilter.Types)) { if (n.NameHash != 0) dd[n.NameHash] = n; } bn.Parent = parentBackup; }
public override void VisitChildren (IBlockNode block) { if (!halt) shownKeywords.Push(BlockMemberFilter); var en = block.GetEnumerator (); while (!halt && en.MoveNext ()) { if (en.Current.Location > ed.CaretLocation) { halt = true; return; } en.Current.Accept (this); } if (!halt) shownKeywords.Pop (); }
void SearchResultsIn(IBlockNode block, string pattern, List<INode> results, int maxResults) { // Don't search in modules themselves! if (block.Children.Count == 0 || results.Count > maxResults) return; foreach (var n in block.Children) { if(!results.Contains(n) && n.Name.Contains(pattern)) if(!results.Contains(n)) results.Add(n); if(n is IBlockNode) SearchResultsIn(n as IBlockNode, pattern, results, maxResults); if (results.Count > maxResults) return; } }
public void FinishUpdate() { if (!hasBegun) return; hasBegun = false; int lineDiff = Editor.Caret.Line - currentLine; int colDiff = Editor.Caret.Column - currentCol; while (currentBlock != null) { if (isBeforeBlockStart) { currentBlock.BlockStartLocation = new CodeLocation( currentBlock.BlockStartLocation.Column + (currentBlock.BlockStartLocation.Line == Editor.Caret.Line ? colDiff : 0), currentBlock.BlockStartLocation.Line + lineDiff); isBeforeBlockStart = false; } currentBlock.EndLocation = new CodeLocation( currentBlock.EndLocation.Column + (currentBlock.EndLocation.Line == Editor.Caret.Line ? colDiff : 0), currentBlock.EndLocation.Line + lineDiff); currentBlock = currentBlock.Parent as IBlockNode; } while (currentStmt != null) { if (isAtStmtStart) { isAtStmtStart = currentStmt.Parent != null && currentStmt.Location == currentStmt.Parent.Location; currentStmt.Location = new CodeLocation( currentStmt.Location.Column + colDiff, currentStmt.Location.Line + lineDiff); } currentStmt.EndLocation = new CodeLocation( currentStmt.EndLocation.Column + (currentStmt.EndLocation.Line == Editor.Caret.Line ? colDiff : 0), currentStmt.EndLocation.Line + lineDiff); currentStmt = currentStmt.Parent; } }
static void HandleNewExpression(NewExpression nex, ArgumentsResolutionResult res, IEditorData Editor, ResolutionContext ctxt, IBlockNode curBlock, IEnumerable<AbstractType> resultBases = null) { res.MethodIdentifier = nex; CalculateCurrentArgument(nex, res, Editor.CaretLocation, ctxt); var type = TypeDeclarationResolver.ResolveSingle(nex.Type, ctxt); var _ctors = new List<AbstractType>(); if (type is AmbiguousType) foreach (var t in (type as AmbiguousType).Overloads) HandleNewExpression_Ctor(nex, curBlock, _ctors, t); else HandleNewExpression_Ctor(nex, curBlock, _ctors, type); res.ResolvedTypesOrMethods = _ctors.ToArray(); }
/// <summary> /// Used for caching available types. /// </summary> protected override void OnScopedBlockChanged(IBlockNode bn) { Dictionary<int,byte> dd = null; foreach (var n in ItemEnumeration.EnumScopedBlockChildren(ctxt, MemberFilter.Types | MemberFilter.Enums)) { if (n.NameHash != 0) { if (dd == null && !TypeCache.TryGetValue (bn, out dd)) TypeCache [bn] = dd = new Dictionary<int,byte> (); byte type = 0; if (n is DClassLike) type = (n as DClassLike).ClassType; else if (n is DEnum) type = DTokens.Enum; else if (n is TemplateParameter.Node) type = DTokens.Not; // Only needed for highlighting and thus just a convention question dd[n.NameHash] = type; } } }
static void HandleNewExpression(NewExpression nex, ArgumentsResolutionResult res, IEditorData Editor, ResolverContextStack ctxt, IBlockNode curBlock) { res.MethodIdentifier = nex; CalculateCurrentArgument(nex, res, Editor.CaretLocation, ctxt); var type = TypeDeclarationResolver.ResolveSingle(nex.Type, ctxt) as ClassType; //TODO: Inform the user that only classes can be instantiated if (type != null) { var constructors = new List<DMethod>(); bool explicitCtorFound = false; foreach (var member in type.Definition) { var dm = member as DMethod; if (dm != null && dm.SpecialType == DMethod.MethodType.Constructor) { explicitCtorFound = true; if (!dm.IsPublic) { var curNode = curBlock; bool pass = false; do { if (curNode == type.Definition) { pass = true; break; } } while ((curNode = curNode.Parent as IBlockNode) != curNode); if (!pass) continue; } constructors.Add(dm); } } if (constructors.Count == 0) { if (explicitCtorFound) { // TODO: Somehow inform the user that the current class can't be instantiated } else { // Introduce default constructor constructors.Add(new DMethod(DMethod.MethodType.Constructor) { Description = "Default constructor for " + type.Name, Parent = type.Definition }); } } // Wrapp all ctor members in MemberSymbols var _ctors = new List<AbstractType>(); foreach (var ctor in constructors) _ctors.Add(new MemberSymbol(ctor, type, nex.Type)); res.ResolvedTypesOrMethods = _ctors.ToArray(); //TODO: Probably pre-select the current ctor by handling previously typed arguments etc. } }
public static void RemoveDoubles(IBlockNode originalAst, IBlockNode blockToClean) { var rem = new DoubleDeclarationSilencer(); originalAst.Accept(rem); rem.secondRun = true; blockToClean.Accept(rem); }
public virtual void VisitChildren(IBlockNode block) { foreach (var n in block) n.Accept(this); }
private static void HandleNewExpression_Ctor(NewExpression nex, IBlockNode curBlock, List<AbstractType> _ctors, AbstractType t) { var udt = t as TemplateIntermediateType; if (udt is ClassType || udt is StructType) { bool explicitCtorFound = false; var constructors = new List<DMethod>(); //TODO: Mixed-in ctors? --> Convert to AbstractVisitor/use NameScan foreach (var member in udt.Definition) { var dm = member as DMethod; if (dm != null && dm.SpecialType == DMethod.MethodType.Constructor) { explicitCtorFound = true; if (!dm.IsPublic) { var curNode = curBlock; bool pass = false; do { if (curNode == udt.Definition) { pass = true; break; } } while ((curNode = curNode.Parent as IBlockNode) != curNode); if (!pass) continue; } constructors.Add(dm); } } if (constructors.Count == 0) { if (explicitCtorFound) { // TODO: Somehow inform the user that the current class can't be instantiated } else { // Introduce default constructor constructors.Add(new DMethod(DMethod.MethodType.Constructor) { Description = "Default constructor for " + udt.Name, Parent = udt.Definition }); } } // Wrapp all ctor members in MemberSymbols foreach (var ctor in constructors) _ctors.Add(new MemberSymbol(ctor, t, nex.Type)); } }
public static ISyntaxRegion FindCurrentCaretContext(IEditorData editor, out ParserTrackerVariables trackerVariables, ref IBlockNode currentScope, out IStatement currentStatement) { if(currentScope == null) currentScope = DResolver.SearchBlockAt (editor.SyntaxTree, editor.CaretLocation, out currentStatement); if (currentScope == null) { trackerVariables = null; currentStatement = null; return null; } bool ParseDecl = false; int blockStart = 0; var blockStartLocation = currentScope != null ? currentScope.BlockStartLocation : editor.CaretLocation; if (currentScope is DMethod) { var block = (currentScope as DMethod).GetSubBlockAt(editor.CaretLocation); if (block != null) blockStart = DocumentHelper.GetOffsetByRelativeLocation (editor.ModuleCode, editor.CaretLocation, editor.CaretOffset, blockStartLocation = block.Location); else { currentScope = currentScope.Parent as IBlockNode; return FindCurrentCaretContext (editor, out trackerVariables, ref currentScope, out currentStatement); } } else if (currentScope != null) { if (currentScope.BlockStartLocation.IsEmpty || (editor.CaretLocation < currentScope.BlockStartLocation && editor.CaretLocation > currentScope.Location)) { ParseDecl = true; blockStart = DocumentHelper.GetOffsetByRelativeLocation(editor.ModuleCode, editor.CaretLocation, editor.CaretOffset, blockStartLocation = currentScope.Location); } else blockStart = DocumentHelper.GetOffsetByRelativeLocation(editor.ModuleCode, editor.CaretLocation, editor.CaretOffset, currentScope.BlockStartLocation); } if (blockStart >= 0 && editor.CaretOffset - blockStart > 0) using (var sr = new Misc.StringView(editor.ModuleCode, blockStart, editor.CaretOffset - blockStart)) { var psr = DParser.Create(sr); /* Deadly important! For correct resolution behaviour, * it is required to set the parser virtually to the blockStart position, * so that everything using the returned object is always related to * the original code file, not our code extraction! */ psr.Lexer.SetInitialLocation(blockStartLocation); ISyntaxRegion ret = null; if (currentScope == null) ret = psr.Parse(); else if (currentScope is DMethod) { psr.Step(); var dm = currentScope as DMethod; dm.Clear(); if ((dm.SpecialType & DMethod.MethodType.Lambda) != 0 && psr.Lexer.LookAhead.Kind != DTokens.OpenCurlyBrace) { psr.LambdaSingleStatementBody (dm); ret = dm.Body; } else { var methodRegion = DTokens.Body; if (dm.In != null && blockStartLocation == dm.In.Location) methodRegion = DTokens.In; if (dm.Out != null && blockStartLocation == dm.Out.Location) methodRegion = DTokens.Out; var newBlock = psr.BlockStatement (currentScope); ret = newBlock; switch (methodRegion) { case DTokens.Body: newBlock.EndLocation = dm.Body.EndLocation; dm.Body = newBlock; break; case DTokens.In: newBlock.EndLocation = dm.In.EndLocation; dm.In = newBlock; break; case DTokens.Out: newBlock.EndLocation = dm.Out.EndLocation; dm.Out = newBlock; break; } } } else if (currentScope is DModule) ret = psr.Root(); else { psr.Step(); if (ParseDecl) { var ret2 = psr.Declaration(currentScope); if (ret2 != null && ret2.Length > 0) ret = ret2[0]; } else if (currentScope is DClassLike) { var t = new DClassLike((currentScope as DClassLike).ClassType); t.AssignFrom(currentScope); t.Clear(); psr.ClassBody(t); ret = t; } else if (currentScope is DEnum) { var t = new DEnum(); t.AssignFrom(currentScope); t.Clear(); psr.EnumBody(t); ret = t; } } currentScope = DResolver.SearchBlockAt (currentScope, psr.Lexer.CurrentToken != null ? psr.Lexer.CurrentToken.EndLocation : editor.CaretLocation, out currentStatement); trackerVariables = psr.TrackerVariables; return ret; } trackerVariables = null; currentStatement = null; return null; }
private ParameterInsightResolution(IEditorData ed, ResolutionContext c, ArgumentsResolutionResult r, IBlockNode cs) { Editor = ed; ctxt = c; res = r; curScope = cs; }
static void HandleTemplateInstance(TemplateInstanceExpression tix, ArgumentsResolutionResult res, IEditorData Editor, ResolutionContext ctxt, IBlockNode curBlock, IEnumerable<AbstractType> resultBases = null) { res.IsTemplateInstanceArguments = true; res.MethodIdentifier = tix; res.ResolvedTypesOrMethods = ExpressionTypeEvaluation.GetOverloads(tix, ctxt, resultBases, false); if (tix.Arguments != null) res.CurrentlyTypedArgumentIndex = tix.Arguments.Length; else res.CurrentlyTypedArgumentIndex = 0; }
protected virtual void OnScopedBlockChanged(IBlockNode bn) { }
private bool GetVisibleMemberFilter(IEditorData Editor, char enteredChar, ref MemberFilter visibleMembers, ref IStatement curStmt) { if (trackVars == null) { // --> Happens if no actual declaration syntax given --> Show types/keywords anyway visibleMembers = MemberFilter.Types | MemberFilter.Keywords | MemberFilter.TypeParameters; } else { var n = trackVars.LastParsedObject as INode; var dv = n as DVariable; if (trackVars.ExpectingNodeName) { if (dv != null && dv.IsAlias && dv.Type == null) { // Show completion because no aliased type has been entered yet } else if (n != null && n.NameHash==0 && enteredChar != '\0') return false; } else if (trackVars.LastParsedObject is TokenExpression && DTokens.BasicTypes[(trackVars.LastParsedObject as TokenExpression).Token] && DTokens.IsIdentifierChar(enteredChar)) return false; if (trackVars.LastParsedObject is Modifier) { var attr = trackVars.LastParsedObject as Modifier; if (attr.IsStorageClass && attr.Token != DTokens.Abstract) return false; } else if (trackVars.IsParsingBaseClassList) { var dc = parsedBlock as DClassLike; if (dc != null && dc.ClassType == DTokens.Interface) visibleMembers = MemberFilter.Interfaces | MemberFilter.Templates; else visibleMembers = MemberFilter.Classes | MemberFilter.Interfaces | MemberFilter.Templates; return true; } if (trackVars.IsParsingAssignExpression) { visibleMembers = MemberFilter.All; return true; } if ((trackVars.LastParsedObject is NewExpression && trackVars.IsParsingInitializer) || trackVars.LastParsedObject is TemplateInstanceExpression && ((TemplateInstanceExpression)trackVars.LastParsedObject).Arguments == null) visibleMembers = MemberFilter.Types; else if (enteredChar == ' ') return false; // In class bodies, do not show variables else if (!(parsedBlock is BlockStatement || trackVars.IsParsingInitializer)) { bool showVariables = false; var dbn = parsedBlock as DBlockNode; if (dbn != null && dbn.StaticStatements != null && dbn.StaticStatements.Count > 0) { var ss = dbn.StaticStatements[dbn.StaticStatements.Count - 1]; if (Editor.CaretLocation > ss.Location && Editor.CaretLocation <= ss.EndLocation) { showVariables = true; } } if (!showVariables) visibleMembers = MemberFilter.All ^ MemberFilter.Variables; } // Hide completion if having typed a '0.' literal else if (trackVars.LastParsedObject is IdentifierExpression && (trackVars.LastParsedObject as IdentifierExpression).Format == LiteralFormat.Scalar) return false; /* * Handle module-scoped things: * When typing a dot without anything following, trigger completion and show types, methods and vars that are located in the module & import scope */ else if (trackVars.LastParsedObject is TokenExpression && ((TokenExpression)trackVars.LastParsedObject).Token == DTokens.Dot) { visibleMembers = MemberFilter.Methods | MemberFilter.Types | MemberFilter.Variables | MemberFilter.TypeParameters; curBlock = Editor.SyntaxTree; curStmt = null; } // In a method, parse from the method's start until the actual caret position to get an updated insight if (visibleMembers.HasFlag(MemberFilter.Variables) && curBlock is DMethod && parsedBlock is BlockStatement) {} else curStmt = null; } return true; }
protected virtual void OnScopeChanged(IBlockNode scopedBlock) { }