protected override void BuildCompletionDataInternal(IEditorData Editor, char enteredChar) { var ctxt = ResolutionContext.Create(Editor, false); foreach (var kv in VersionCompletionItems) { CompletionDataGenerator.AddTextItem(kv.Key, kv.Value); } CodeCompletion.DoTimeoutableCompletionTask(CompletionDataGenerator, ctxt, () => { ctxt.Push(Editor); var cs = ctxt.CurrentContext.DeclarationCondititons; foreach (var v in cs.GlobalFlags.Versions) { if (!VersionCompletionItems.ContainsKey(v)) { CompletionDataGenerator.AddTextItem(v, ""); } } foreach (var v in cs.LocalFlags.Versions) { if (!VersionCompletionItems.ContainsKey(v)) { CompletionDataGenerator.AddTextItem(v, ""); } } }); }
protected override void BuildCompletionDataInternal(IEditorData Editor, char enteredChar) { ed = Editor; ctxt = ResolutionContext.Create(Editor, false); AbstractType t = null; CodeCompletion.DoTimeoutableCompletionTask(CompletionDataGenerator, ctxt, () => { ctxt.Push(Editor); if (AccessExpression is IExpression) { t = ExpressionTypeEvaluation.EvaluateType(AccessExpression as IExpression, ctxt); } else if (AccessExpression is ITypeDeclaration) { t = TypeDeclarationResolver.ResolveSingle(AccessExpression as ITypeDeclaration, ctxt); } }); if (t == null) //TODO: Add after-space list creation when an unbound . (Dot) was entered which means to access the global scope { return; } t.Accept(this); }
protected override IEnumerable <Ide.FindInFiles.MemberReference> GetReferences(Tuple <ResolutionContext, DSymbol> tup, System.Threading.CancellationToken token) { var ctxt = tup.Item1; ctxt.CancellationToken = token; var mr = tup.Item2; var referencedNode = mr.Definition; // Slightly hacky: To keep highlighting the id of e.g. a NewExpression, take the ctor's parent node (i.e. the class node) if (referencedNode is DMethod && ((DMethod)referencedNode).SpecialType == DMethod.MethodType.Constructor) { mr = mr.Base as DSymbol; if (mr == null) { yield break; } referencedNode = mr.Definition; } IEnumerable <ISyntaxRegion> refs = null; CodeCompletion.DoTimeoutableCompletionTask(null, ctxt, () => { try { refs = D_Parser.Refactoring.ReferencesFinder.SearchModuleForASTNodeReferences(SyntaxTree, referencedNode, ctxt); } catch (Exception ex) { LoggingService.LogInfo("Error during highlighting usages", ex); } }); if (refs != null) { foreach (var sr in refs) { CodeLocation loc; int len; if (sr is INode) { loc = (sr as INode).NameLocation; len = (sr as INode).Name.Length; } else if (sr is TemplateParameter) { loc = (sr as TemplateParameter).NameLocation; len = (sr as TemplateParameter).Name.Length; } else { loc = sr.Location; len = sr.EndLocation.Column - loc.Column; } yield return(new Ide.FindInFiles.MemberReference(sr, new ICSharpCode.NRefactory.TypeSystem.DomRegion(Document.FileName, loc.Line, loc.Column, loc.Line, loc.Column + len), Document.Editor.LocationToOffset(loc.Line, loc.Column), len)); } } }
void GenUfcsAndStaticProperties(AbstractType t) { if (t.NonStaticAccess && CompletionOptions.Instance.ShowUFCSItems) { CodeCompletion.DoTimeoutableCompletionTask(null, ctxt, () => { foreach (var ufcsItem in UFCSResolver.TryResolveUFCS(t, 0, ed.CaretLocation, ctxt)) { CompletionDataGenerator.Add((ufcsItem as DSymbol).Definition); } }); } StaticProperties.ListProperties(CompletionDataGenerator, ctxt, MemberFilter, t, t.NonStaticAccess); }
public static Dictionary <int, Dictionary <ISyntaxRegion, byte> > Scan(IEditorData ed, List <ISyntaxRegion> invalidConditionalCodeRegions = null, int timeout = int.MinValue) { if (ed == null || ed.SyntaxTree == null) { return(new Dictionary <int, Dictionary <ISyntaxRegion, byte> >()); } var ctxt = ResolutionContext.Create(ed, false); // Since it's just about enumerating, not checking types, ignore any conditions ctxt.ContextIndependentOptions |= ResolutionOptions.IgnoreDeclarationConditions; var typeRefFinder = new TypeReferenceFinder(ctxt, invalidConditionalCodeRegions); CodeCompletion.DoTimeoutableCompletionTask(null, ctxt, () => ed.SyntaxTree.Accept(typeRefFinder), timeout); return(typeRefFinder.Matches); }
public static AbstractType ResolveType(IEditorData editor, ResolutionContext ctxt = null) { var o = GetScopedCodeObject(editor); if (ctxt == null) { ctxt = ResolutionContext.Create(editor, false); } AbstractType ret = null; CodeCompletion.DoTimeoutableCompletionTask(null, ctxt, () => { ctxt.Push(editor); var optionBackup = ctxt.CurrentContext.ContextDependentOptions; ctxt.CurrentContext.ContextDependentOptions |= ResolutionOptions.ReturnMethodReferencesOnly; if (o is IExpression) { ret = ExpressionTypeEvaluation.EvaluateType((IExpression)o, ctxt, false); } else if (o is ITypeDeclaration) { ret = TypeDeclarationResolver.ResolveSingle((ITypeDeclaration)o, ctxt); } else if (o is INode) { ret = TypeDeclarationResolver.HandleNodeMatch(o as INode, ctxt); } ctxt.CurrentContext.ContextDependentOptions = optionBackup; }); return(ret); }
public static AbstractType ResolveTypeLoosely(IEditorData editor, out NodeResolutionAttempt resolutionAttempt, ResolutionContext ctxt = null) { var o = GetScopedCodeObject(editor); if (ctxt == null) { ctxt = ResolutionContext.Create(editor, false); } AbstractType ret = null; NodeResolutionAttempt resAttempt = NodeResolutionAttempt.Normal; CodeCompletion.DoTimeoutableCompletionTask(null, ctxt, () => { ctxt.Push(editor); var optionBackup = ctxt.CurrentContext.ContextDependentOptions; ctxt.CurrentContext.ContextDependentOptions |= ResolutionOptions.ReturnMethodReferencesOnly | ResolutionOptions.DontResolveAliases; if (o is IExpression) { ret = ExpressionTypeEvaluation.EvaluateType((IExpression)o, ctxt, false); } else if (o is ITypeDeclaration) { ret = TypeDeclarationResolver.ResolveSingle((ITypeDeclaration)o, ctxt); } else if (o is INode) { ret = TypeDeclarationResolver.HandleNodeMatch(o as INode, ctxt, null, o); } else { ret = null; } if (ret == null) { resAttempt = NodeResolutionAttempt.NoParameterOrTemplateDeduction; if (o is PostfixExpression_MethodCall) { o = (o as PostfixExpression_MethodCall).PostfixForeExpression; } ctxt.CurrentContext.ContextDependentOptions |= ResolutionOptions.NoTemplateParameterDeduction | ResolutionOptions.DontResolveAliases; if (o is IdentifierExpression) { ret = AmbiguousType.Get(ExpressionTypeEvaluation.GetOverloads(o as IdentifierExpression, ctxt, deduceParameters: false), o); } else if (o is ITypeDeclaration) { ret = TypeDeclarationResolver.ResolveSingle(o as ITypeDeclaration, ctxt); } else if (o is IExpression) { ret = ExpressionTypeEvaluation.EvaluateType(o as IExpression, ctxt, false); } } if (ret == null) { resAttempt = NodeResolutionAttempt.RawSymbolLookup; var overloads = TypeDeclarationResolver.HandleNodeMatches(LookupIdRawly(editor, o as ISyntaxRegion), ctxt, null, o); ret = AmbiguousType.Get(overloads, o); } ctxt.CurrentContext.ContextDependentOptions = optionBackup; }); resolutionAttempt = resAttempt; if (ret != null) { ret.DeclarationOrExpressionBase = o; } return(ret); }
public ObjectValue Resolve(ulong offset, string symbolname, string typename, string val, DEW.DebugScopedSymbol parentsymbol) { DModule module; int codeLine; INode variableNode = null; // Search currently scoped module string file = ""; uint line = 0; Engine.Symbols.GetLineByOffset(Engine.CurrentInstructionOffset, out file, out line); codeLine = (int)line; if (string.IsNullOrWhiteSpace(file)) { return(null); } AbstractDProject dproj = null; module = GetFileSyntaxTree(file, out dproj); // If syntax tree built, search the variable location if (module != null) { var ed = Resolver.DResolverWrapper.CreateEditorData(IdeApp.Workbench.ActiveDocument); var ctxt = ResolutionContext.Create(ed, false); CodeCompletion.DoTimeoutableCompletionTask(null, ctxt, () => { var loc = new CodeLocation(0, codeLine); ctxt.Push(DResolver.SearchBlockAt(module, loc), loc); AbstractType[] res; if (parentsymbol != null) { var parentres = ResolveParentSymbol(parentsymbol, ctxt); res = TypeDeclarationResolver.ResolveFurtherTypeIdentifier(symbolname, parentres, ctxt, null); } else { res = TypeDeclarationResolver.ResolveIdentifier(symbolname, ctxt, null); } if (res != null && res.Length > 0 && res[0] is DSymbol) { variableNode = (res[0] as DSymbol).Definition; } }); } // Set type string string _typeString = typename; if (variableNode != null) { var t = variableNode.Type; if (t != null) { _typeString = t.ToString(); } } // Set value string string _valueString = val; ObjectValueFlags flags = ObjectValueFlags.Variable; if (variableNode != null) { ITypeDeclaration curValueType = variableNode.Type; if (curValueType != null) { if (!IsBasicType(curValueType)) { if (_typeString == "string") //TODO: Replace this by searching the alias definition in the cache { curValueType = new ArrayDecl() { InnerDeclaration = new DTokenDeclaration(DTokens.Char) } } ; else if (_typeString == "wstring") { curValueType = new ArrayDecl() { InnerDeclaration = new DTokenDeclaration(DTokens.Wchar) } } ; else if (_typeString == "dstring") { curValueType = new ArrayDecl() { InnerDeclaration = new DTokenDeclaration(DTokens.Dchar) } } ; if (IsArray(curValueType)) { flags = ObjectValueFlags.Array; var clampDecl = curValueType as ArrayDecl; var valueType = clampDecl.InnerDeclaration; if (valueType is DTokenDeclaration) { bool IsString = false; uint elsz = 0; var realType = DetermineArrayType((valueType as DTokenDeclaration).Token, out elsz, out IsString); var arr = Engine.Symbols.ReadArray(offset, realType, elsz); if (arr != null) { _valueString = BuildArrayContentString(arr, IsString); } } } else { flags = ObjectValueFlags.Object; } } } } return(ObjectValue.CreatePrimitive(ObjectValueSource, new ObjectPath(symbolname), _typeString, new EvaluationResult(_valueString), flags)); }