Variable ResolveVariable(Variable variable) { Dom.ParseInformation info = ParserService.GetParseInformation(this.textEditor.FileName); Dom.ExpressionResult res = new Dom.ExpressionResult(variable.Name, Dom.DomRegion.FromLocation(variable.StartPos, variable.EndPos), Dom.ExpressionContext.Default, null); Dom.ResolveResult result = this.GetResolver().Resolve(res, info, this.textEditor.Document.Text); Dom.IReturnType type = currentProjectContent.SystemTypes.Object; Dom.ClassFinder finder = new Dom.ClassFinder(currentClass, textEditor.Caret.Line, textEditor.Caret.Column); if (result != null && result.ResolvedType != null) { type = result.ResolvedType; } if (variable.Type.Type == "var") { variable.Type = Dom.Refactoring.CodeGenerator.ConvertType(type, finder); } variable.IsReferenceType = type.IsReferenceType == true; return(variable); }
/// <summary> /// Find the expression the cursor is at. /// Also determines the context (using statement, "new"-expression etc.) the /// cursor is at. /// </summary> Dom.ExpressionResult FindExpression(TextArea textArea) { Dom.IExpressionFinder finder = new Dom.CSharp.CSharpExpressionFinder(mainForm.parseInformation); Dom.ExpressionResult expression = finder.FindExpression(textArea.Document.TextContent, textArea.Caret.Offset); if (expression.Region.IsEmpty) { expression.Region = new Dom.DomRegion(textArea.Caret.Line + 1, textArea.Caret.Column + 1); } //the previous char must be empty. if (textArea.Caret.Offset > 0) { string text = textArea.Document.GetText(textArea.Caret.Offset - 1, 1); //if (char.IsLetterOrDigit(text[0]) || text == "'" || text == ".") if (text != " " && text != "\n") { expression.Expression = "xxx"; } else { expression.Expression = ""; } } return(expression); }
public void Init() { string code = "from System import "; int offset = 19; PythonExpressionFinder expressionFinder = new PythonExpressionFinder(); expressionResult = expressionFinder.FindExpression(code, offset); }
public void MathModuleExpressionShouldNotHaveAnyCompletionItemsSinceMathModuleIsNotImported() { ExpressionResult result = new ExpressionResult("math", ExpressionContext.Default); resolveResult = resolver.Resolve(result, parseInfo, GetPythonScript()); Assert.IsNull(resolveResult); }
public ResolveResult Resolve(ExpressionResult expressionResult, ParseInformation parseInfo, string fileContent) { if (parseInfo == null || (string.IsNullOrEmpty(fileContent) && !(expressionResult.Context is XamlContext))) return null; this.resolveExpression = expressionResult.Expression; this.caretLine = expressionResult.Region.BeginLine; this.caretColumn = expressionResult.Region.BeginColumn; this.callingClass = parseInfo.CompilationUnit.GetInnermostClass(caretLine, caretColumn); this.context = expressionResult.Context as XamlContext ?? CompletionDataHelper.ResolveContext(fileContent, parseInfo.CompilationUnit.FileName, Utils.GetOffsetFromFilePos(fileContent, caretLine, caretColumn)); switch (this.context.Description) { case XamlContextDescription.AtTag: case XamlContextDescription.None: return ResolveElementName(resolveExpression); case XamlContextDescription.InTag: return ResolveAttribute(resolveExpression) ?? ResolveElementName(resolveExpression); case XamlContextDescription.InAttributeValue: MemberResolveResult mrr = ResolveAttribute(context.Attribute.Name); if (mrr != null) { var rr = ResolveAttributeValue(mrr.ResolvedMember, resolveExpression) ?? mrr; return rr; } break; case XamlContextDescription.InMarkupExtension: return ResolveMarkupExtension(resolveExpression); } return null; }
public ResolveResult Resolve(string expression) { ExpressionResult expressionResult = new ExpressionResult(expression); PythonResolverContext context = new PythonResolverContext(ParseInfo, expressionResult, String.Empty); ResolveResult = Resolver.Resolve(context); return ResolveResult; }
public void Init() { string text = "import\r\n"; PythonExpressionFinder expressionFinder = new PythonExpressionFinder(); int offset = 8; // Cursor is just after \r\n on second line. result = expressionFinder.FindExpression(text, offset); }
public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult) { ResolveResult resolveResult = dotNetMethodResolver.Resolve(resolverContext, expressionResult); if (resolveResult != null) { return resolveResult; } return standardModuleMethodResolver.Resolve(resolverContext, expressionResult); }
public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult) { IProperty property = FindProperty(resolverContext, expressionResult.Expression); if (property != null) { return CreateMemberResolveResult(property); } return null; }
public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult) { PythonStandardModuleType type = GetStandardModuleTypeIfImported(resolverContext, expressionResult.Expression); if (type != null) { return new PythonStandardModuleResolveResult(type); } return null; }
public PythonResolverContext(ParseInformation parseInfo, ExpressionResult expressionResult, string fileContent) { this.fileContent = fileContent; this.expressionResult = expressionResult; GetCompilationUnit(parseInfo); GetProjectContent(); GetCallingMember(); }
void ResolvePropertyExpression(string expression) { PythonResolverContext context = new PythonResolverContext(parseInfo); ExpressionResult expressionResult = new ExpressionResult(expression); PythonResolver resolver = new PythonResolver(); result = resolver.Resolve(context, expressionResult); }
public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult) { IClass matchingClass = GetClass(resolverContext, expressionResult.Expression); if (matchingClass != null) { return CreateTypeResolveResult(matchingClass); } return null; }
public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult) { MemberName memberName = new MemberName(expressionResult.Expression); IClass matchingClass = classResolver.GetClass(resolverContext, memberName.Type); if (matchingClass != null) { return new PythonMethodGroupResolveResult(matchingClass, memberName.Name); } return null; }
public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult) { if (resolverContext.HasCallingClass) { if (IsSelfExpression(expressionResult)) { return CreateResolveResult(resolverContext); } } return null; }
public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult) { this.resolverContext = resolverContext; this.expressionResult = expressionResult; if (resolverContext.HasImport(expressionResult.Expression)) { return ResolveFullNamespace(); } return ResolvePartialNamespaceMatch(); }
public RefactoringMenuContext(ITextEditor editor, ExpressionResult expressionResult, ResolveResult resolveResult, bool isDefinition, IProjectContent projectContent, ICompilationUnit compilationUnit) { this.Editor = editor; this.ExpressionResult = expressionResult; this.ResolveResult = resolveResult; this.IsDefinition = isDefinition; this.ProjectContent = projectContent; this.CompilationUnit = compilationUnit; }
public override IInsightItem[] ProvideInsight(ExpressionResult expressionResult, ResolveResult result) { if (result == null) return null; IReturnType type = result.ResolvedType; if (type == null) return null; return (from p in type.GetProperties() where p.IsIndexer select new MethodInsightItem(p) ).ToArray(); }
/// <summary> /// Tries to find a resource reference in the specified expression. /// </summary> /// <param name="expressionResult">The ExpressionResult for the expression.</param> /// <param name="expr">The AST representation of the full expression.</param> /// <param name="resolveResult">SharpDevelop's ResolveResult for the expression.</param> /// <param name="caretLine">The 0-based line where the expression is located.</param> /// <param name="caretColumn">The 0-based column where the expression is located.</param> /// <param name="fileName">The name of the source file where the expression is located.</param> /// <param name="fileContent">The content of the source file where the expression is located.</param> /// <param name="expressionFinder">The ExpressionFinder for the file.</param> /// <param name="charTyped">The character that has been typed at the caret position but is not yet in the buffer (this is used when invoked from code completion), or <c>null</c>.</param> /// <returns>A ResourceResolveResult describing the referenced resource, or <c>null</c>, if this expression does not reference a resource using the ICSharpCode.Core.ResourceService class.</returns> public ResourceResolveResult Resolve(ExpressionResult expressionResult, Expression expr, ResolveResult resolveResult, int caretLine, int caretColumn, string fileName, string fileContent, IExpressionFinder expressionFinder, char? charTyped) { IMember member = null; // "ResourceService.GetString(..." may be a MemberResolveResult or // MethodResolveResult, dependent on how much of the expression // has already been typed. MemberResolveResult mrr = resolveResult as MemberResolveResult; if (mrr != null) { // If it is a MemberResolveResult, this indicates that // the complete expression is already in the buffer. // So we only assign the member if Resolve is not invoked // from code completion to prevent the code completion window // from opening when typing something like: // ResourceService.GetString(...)[ if (charTyped == null) { member = mrr.ResolvedMember; } } else { MethodGroupResolveResult methrr = resolveResult as MethodGroupResolveResult; if (methrr != null) { // If it is a MethodResolveResult, the expression is incomplete. // Accept only if '(' has been typed. if (charTyped == '(') { member = methrr.GetMethodIfSingleOverload(); } } } if (member is IMethod && LanguageProperties.CSharp.NameComparer.Equals(member.FullyQualifiedName, "ICSharpCode.Core.ResourceService.GetString") ) { #if DEBUG LoggingService.Debug("ResourceToolkit: ICSharpCodeCoreNRefactoryResourceResolver: ResourceService resource access detected"); #endif string key = GetKeyFromExpression(expr); // TODO: Add information about return type (of the resource, if present). return new ResourceResolveResult(resolveResult.CallingClass, resolveResult.CallingMember, null, ICSharpCodeCoreResourceResolver.ResolveICSharpCodeCoreResourceSet(key, fileName), key); } return null; }
public ResolveResult Resolve(ExpressionResult expressionResult, ParseInformation parseInfo, string fileContent) { if (String.IsNullOrEmpty(fileContent)) { return null; } resolverContext = new PythonResolverContext(parseInfo, expressionResult, fileContent); if (!resolverContext.HasProjectContent) { return null; } return Resolve(resolverContext); }
public void InitBase() { projectContent = new MockProjectContent(); PythonParser parser = new PythonParser(); string fileName = @"C:\projects\test\test.py"; compilationUnit = parser.Parse(projectContent, fileName, GetPythonScript()); parseInfo = new ParseInformation(compilationUnit); resolver = new PythonResolver(); expressionResult = GetExpressionResult(); resolveResult = resolver.Resolve(expressionResult, parseInfo, GetPythonScript()); }
/// <summary> /// Find the expression the cursor is at. /// Also determines the context (using statement, "new"-expression etc.) the /// cursor is at. /// </summary> Dom.ExpressionResult FindExpression(TextArea textArea) { Dom.IExpressionFinder finder; finder = new Dom.CSharp.CSharpExpressionFinder(mainForm.parseInformation); Dom.ExpressionResult expression = finder.FindExpression(textArea.Document.TextContent, textArea.Caret.Offset); if (expression.Region.IsEmpty) { expression.Region = new Dom.DomRegion(textArea.Caret.Line + 1, textArea.Caret.Column + 1); } return(expression); }
public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult) { MemberName memberName = new MemberName(expressionResult.Expression); MethodGroupResolveResult result = ResolveMethodFromImportedNames(resolverContext, memberName); if (result != null) { return result; } result = ResolveIfMethodIsImported(resolverContext, memberName); if (result != null) { return result; } return ResolveMethodFromModulesThatImportEverything(resolverContext, memberName); }
public ResolveResult Resolve(ExpressionResult expressionResult, ParseInformation parseInfo, string fileContent) { if (String.IsNullOrEmpty(fileContent)) { return null; } resolverContext = new PythonResolverContext(parseInfo); if (!resolverContext.GetCallingMember(expressionResult.Region)) { return null; } return Resolve(resolverContext, expressionResult); }
protected override void SetupDataProvider(string fileName, IDocument document, ExpressionResult expressionResult, int caretLineNumber, int caretColumn) { ResolveResult result = ParserService.Resolve(expressionResult, caretLineNumber, caretColumn, fileName, document.TextContent); if (result == null) return; IReturnType type = result.ResolvedType; if (type == null) return; foreach (IProperty i in type.GetProperties()) { if (i.IsIndexer) { methods.Add(i); } } }
public virtual ICompletionItemList GenerateCompletionListForExpression(ITextEditor editor, ExpressionResult expressionResult) { if (expressionResult.Expression == null) { return null; } if (LoggingService.IsDebugEnabled) { if (expressionResult.Context == ExpressionContext.Default) LoggingService.DebugFormatted("GenerateCompletionData for >>{0}<<", expressionResult.Expression); else LoggingService.DebugFormatted("GenerateCompletionData for >>{0}<<, context={1}", expressionResult.Expression, expressionResult.Context); } ResolveResult rr = Resolve(editor, expressionResult); return GenerateCompletionListForResolveResult(rr, expressionResult.Context); }
protected void GenerateCompletionData(TextArea textArea, ExpressionResult expressionResult) { // allow empty string as expression (for VB 'With' statements) if (expressionResult.Expression == null) { return; } if (LoggingService.IsDebugEnabled) { if (expressionResult.Context == ExpressionContext.Default) LoggingService.DebugFormatted("GenerateCompletionData for >>{0}<<", expressionResult.Expression); else LoggingService.DebugFormatted("GenerateCompletionData for >>{0}<<, context={1}", expressionResult.Expression, expressionResult.Context); } string textContent = textArea.Document.TextContent; ResolveResult rr = Resolve(expressionResult, caretLineNumber, caretColumn, fileName, textContent); AddResolveResults(rr, expressionResult.Context); }
Variable ResolveVariable(Variable variable) { Dom.ParseInformation info = ParserService.GetParseInformation(this.textEditor.FileName); Dom.ExpressionResult res = new Dom.ExpressionResult(variable.Name, Dom.DomRegion.FromLocation(variable.StartPos, variable.EndPos), Dom.ExpressionContext.Default, null); Dom.ResolveResult result = this.GetResolver().Resolve(res, info, this.textEditor.Document.TextContent); if (variable.Type.Type == "var") { variable.Type = Dom.Refactoring.CodeGenerator.ConvertType(result.ResolvedType, new Dom.ClassFinder(result.CallingMember)); } variable.IsReferenceType = result.ResolvedType.IsReferenceType == true; return(variable); }
public void Resolve_FieldHasNoReturnType_DoesNotThrowNullReferenceException() { MockProjectContent projectContent = new MockProjectContent(); UnitTestingUtils.MockClass c = new UnitTestingUtils.MockClass(projectContent, "Test"); projectContent.SetClassToReturnFromGetClass("self", c); DefaultField field = c.AddField("randomNumber"); field.ReturnType = null; ParseInformation parseInfo = new ParseInformation(c.CompilationUnit); ExpressionResult expression = new ExpressionResult("self.randomNumber.randint", ExpressionContext.Default); PythonClassResolver classResolver = new PythonClassResolver(); PythonLocalVariableResolver localVariableResolver = new PythonLocalVariableResolver(classResolver); PythonMemberResolver resolver = new PythonMemberResolver(classResolver, localVariableResolver); PythonResolverContext context = new PythonResolverContext(parseInfo, expression, "class Test:\r\npass"); Assert.DoesNotThrow(delegate { resolver.Resolve(context); }); }
public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult) { foreach (IPythonResolver resolver in resolvers) { ResolveResult resolveResult = resolver.Resolve(resolverContext, expressionResult); if (resolveResult != null) { return resolveResult; } } // // Search for a local variable. // LocalResolveResult localResolveResult = GetLocalVariable(expressionResult.Expression, parseInfo.BestCompilationUnit.FileName, fileContent); // if (localResolveResult != null) { // return localResolveResult; // } return null; }
/// <summary> /// Find the expression the cursor is at. /// Also determines the context (using statement, "new"-expression etc.) the /// cursor is at. /// </summary> Dom.ExpressionResult FindExpression(TextArea textArea) { Dom.IExpressionFinder finder; if (IntellisenseForm.SupportedLanguage == ESupportedLanguage.VisualBasic) { finder = new Dom.VBNet.VBExpressionFinder(); } else { finder = new Dom.CSharp.CSharpExpressionFinder(iForm.ParseInformation); } Dom.ExpressionResult expression = finder.FindExpression(textArea.Document.TextContent, textArea.Caret.Offset); if (expression.Region.IsEmpty) { expression.Region = new Dom.DomRegion(textArea.Caret.Line + 1, textArea.Caret.Column + 1); } return(expression); }
public void SetUpFixture() { resolver = new PythonResolver(); mockProjectContent = new ICSharpCode.Scripting.Tests.Utils.MockProjectContent(); systemConsoleClass = new MockClass(mockProjectContent, "System.Console"); mockProjectContent.ClassToReturnFromGetClass = systemConsoleClass; compilationUnit = CreateCompilationUnit(mockProjectContent); ParseInformation parseInfo = new ParseInformation(compilationUnit); string python = GetPythonScript(); ExpressionResult expressionResult = new ExpressionResult("System.Console", new DomRegion(3, 2), null, null); resolveResult = resolver.Resolve(expressionResult, parseInfo, python); // Check that the best compilation unit is used and the resolve // still works. invalidMostRecentCompilationUnitResolveResult = resolver.Resolve(expressionResult, parseInfo, python); }
public void SetUpFixture() { resolver = new PythonResolver(); mockProjectContent = new MockProjectContent(); mockProjectContent.AddExistingNamespaceContents("System", new List<ICompletionEntry>()); string python = "import System\r\n" + "class Test:\r\n" + " def __init__(self):\r\n" + " System.\r\n"; PythonParser parser = new PythonParser(); string fileName = @"C:\Projects\Test\test.py"; DefaultCompilationUnit cu = parser.Parse(mockProjectContent, fileName, python) as DefaultCompilationUnit; ParseInformation parseInfo = new ParseInformation(cu); ExpressionResult expressionResult = new ExpressionResult("System", new DomRegion(4, 2), null, null); resolveResult = resolver.Resolve(expressionResult, parseInfo, python) as NamespaceResolveResult; }
public void SetupDataProvider(string fileName, TextArea textArea) { if (setupOnlyOnce && this.textArea != null) return; IDocument document = textArea.Document; this.fileName = fileName; this.document = document; this.textArea = textArea; int useOffset = (lookupOffset < 0) ? textArea.Caret.Offset : lookupOffset; initialOffset = useOffset; ExpressionResult expressionResult = new ExpressionResult(TextUtilities.GetExpressionBeforeOffset(textArea, useOffset)); if (expressionResult.Expression == null) // expression is null when cursor is in string/comment return; expressionResult.Expression = expressionResult.Expression.Trim(); string expression = (expressionResult.Expression ?? "").Trim(); if (!string.IsNullOrEmpty(expression)) { if (mainForm.Specification != null) { DefaultMethod m = new DefaultMethod(dummyClass, expression); string[] parameters = mainForm.Specification.GetParameterNames(expression); if(parameters != null) { foreach (string parameter in parameters) { m.Parameters.Add(new DefaultParameter(parameter, varClass.DefaultReturnType, DomRegion.Empty)); } //// for the insight window, remove first parameter and mark the //// method as normal - this is required to show the list of //// parameters the method expects. m.IsExtensionMethod = false; methods.Add(m); } } } // foreach (KeyValuePair<string, List<FuncStruct>> pair in PredefinedFuncTable.symbolTableList) // { // if (pair.Key == expression) // { // string funName = pair.Key; // foreach (FuncStruct func in pair.Value) // { // if (func.getFuncName() != null) // { // DefaultMethod m = new DefaultMethod(dummyClass, funName); // m.ReturnType = GetType(func.getReturnType()); // //m.Documentation = func.Description; // List<int> types = func.getParamTypes(); // List<string> names = func.getParamNames(); // for (int i = 0; i < types.Count; i++) // { // int type = types[i]; // string name = names[i]; // m.Parameters.Add(new DefaultParameter(name, GetType(type), DomRegion.Empty)); // } // //// for the insight window, remove first parameter and mark the // //// method as normal - this is required to show the list of // //// parameters the method expects. // m.IsExtensionMethod = false; // //m.Parameters.RemoveAt(0); // methods.Add(m); // } // } // } // } //} //if (setupOnlyOnce && this.textArea != null) return; //IDocument document = textArea.Document; //this.fileName = fileName; //this.document = document; //this.textArea = textArea; //int useOffset = (lookupOffset < 0) ? textArea.Caret.Offset : lookupOffset; //initialOffset = useOffset; //IExpressionFinder expressionFinder = ParserService.GetExpressionFinder(fileName); //ExpressionResult expressionResult; //if (expressionFinder == null) // expressionResult = new ExpressionResult(TextUtilities.GetExpressionBeforeOffset(textArea, useOffset)); //else // expressionResult = expressionFinder.FindExpression(textArea.Document.TextContent, useOffset); //if (expressionResult.Expression == null) // expression is null when cursor is in string/comment // return; //expressionResult.Expression = expressionResult.Expression.Trim(); //if (LoggingService.IsDebugEnabled) { // if (expressionResult.Context == ExpressionContext.Default) // LoggingService.DebugFormatted("ShowInsight for >>{0}<<", expressionResult.Expression); // else // LoggingService.DebugFormatted("ShowInsight for >>{0}<<, context={1}", expressionResult.Expression, expressionResult.Context); //} //int caretLineNumber = document.GetLineNumberForOffset(useOffset); //int caretColumn = useOffset - document.GetLineSegment(caretLineNumber).Offset; //// the parser works with 1 based coordinates //SetupDataProvider(fileName, document, expressionResult, caretLineNumber + 1, caretColumn + 1); }
/// <summary> /// Tries to find a resource reference in the specified expression. /// </summary> /// <param name="expressionResult">The ExpressionResult for the expression.</param> /// <param name="expr">The AST representation of the full expression.</param> /// <param name="resolveResult">SharpDevelop's ResolveResult for the expression.</param> /// <param name="caretLine">The 0-based line where the expression is located.</param> /// <param name="caretColumn">The 0-based column where the expression is located.</param> /// <param name="fileName">The name of the source file where the expression is located.</param> /// <param name="fileContent">The content of the source file where the expression is located.</param> /// <param name="expressionFinder">The ExpressionFinder for the file.</param> /// <param name="charTyped">The character that has been typed at the caret position but is not yet in the buffer (this is used when invoked from code completion), or <c>null</c>.</param> /// <returns>A ResourceResolveResult describing the referenced resource, or <c>null</c>, if this expression does not reference a resource using the standard .NET framework classes.</returns> public ResourceResolveResult Resolve(ExpressionResult expressionResult, Expression expr, ResolveResult resolveResult, int caretLine, int caretColumn, string fileName, string fileContent, IExpressionFinder expressionFinder, char? charTyped) { /* * We need to catch the following cases here: * * Something.GetString( * Something.GetString("...") * Something.ApplyResources(obj, "...") * Something[ * Something["..."] * */ if (charTyped == '(') { // Something.GetString // This is a MethodResolveResult and we need the reference to "Something", // which is the next outer expression. // This is only valid when invoked from code completion // and the method invocation character ('(' in C# and VB) // has been typed. // This code is also reused when reducing a complete InvocationExpression // (MemberResolveResult) to the method reference by passing '(' as // charTyped explicitly. MethodGroupResolveResult methrr = resolveResult as MethodGroupResolveResult; if (methrr != null) { if ((methrr.Name == "GetString" || methrr.Name == "GetObject" || methrr.Name == "GetStream" || methrr.Name == "ApplyResources") && (resolveResult = NRefactoryAstCacheService.ResolveNextOuterExpression(ref expressionResult, caretLine, caretColumn, fileName, fileContent, expressionFinder)) != null) { return ResolveResource(resolveResult, expr); } else { return null; } } } // Do not use "else if" here. // '(' is also the IndexerExpressionStartToken for VB, // so the "else" block further down might still apply. if (charTyped == null) { // A MemberResolveResult with a complete expression // must only be considered a valid resource reference // when Resolve is not invoked from code completion // (i.e. charTyped == null) because this indicates // that the resource reference is already before the typed character // and we are not interested in the following expression. // This may happen when typing something like: // Something.GetString("...")[ MemberResolveResult mrr = resolveResult as MemberResolveResult; if (mrr != null) { if (mrr.ResolvedMember is IMethod && (mrr.ResolvedMember.Name == "GetString" || mrr.ResolvedMember.Name == "GetObject" || mrr.ResolvedMember.Name == "GetStream" || mrr.ResolvedMember.Name == "ApplyResources")) { // Something.GetString("...") // This is a MemberResolveResult and we need the reference to "Something". // The expression finder may only remove the string literal, so // we have to call Resolve again in this case to resolve // the method reference. if ((resolveResult = NRefactoryAstCacheService.ResolveNextOuterExpression(ref expressionResult, caretLine, caretColumn, fileName, fileContent, expressionFinder)) != null) { if (resolveResult is MethodGroupResolveResult) { return this.Resolve(expressionResult, expr, resolveResult, caretLine, caretColumn, fileName, fileContent, expressionFinder, '('); } else { return ResolveResource(resolveResult, expr); } } else { return null; } } else if (expr is IndexerExpression && IsResourceManager(mrr.ResolvedMember.DeclaringType.DefaultReturnType, fileName)) { // Something["..."] is an IndexerExpression. // We need the reference to Something and this is // the next outer expression. if ((resolveResult = NRefactoryAstCacheService.ResolveNextOuterExpression(ref expressionResult, caretLine, caretColumn, fileName, fileContent, expressionFinder)) != null) { return ResolveResource(resolveResult, expr); } else { return null; } } } } else { // This request is triggered from code completion. // The only case that has not been caught above is: // Something[ // The reference to "Something" is already in this expression. // So we have to test the trigger character against the // indexer expression start token of the file's language. LanguageProperties lp = NRefactoryResourceResolver.GetLanguagePropertiesForFile(fileName); if (lp != null && !String.IsNullOrEmpty(lp.IndexerExpressionStartToken) && lp.IndexerExpressionStartToken[0] == charTyped) { #if DEBUG LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver: Indexer expression start typed, ResolveResult: "+resolveResult.ToString()); LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver: -> Expression: "+expr.ToString()); #endif return ResolveResource(resolveResult, expr); } } return null; }
public static ResolveResult GetResultFromDeclarationLine(IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, ExpressionResult expressionResult) { string expression = expressionResult.Expression; if (expression == null) { return(null); } if (callingClass == null) { return(null); } int pos = expression.IndexOf('('); if (pos >= 0) { expression = expression.Substring(0, pos); } expression = expression.Trim(); // if (!callingClass.BodyRegion.IsInside(caretLine, caretColumn) // && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingClass.Name)) // { // return new TypeResolveResult(callingClass, callingMember, callingClass); // } if (expressionResult.Context != ExpressionContext.Type) { if (callingMember != null && !callingMember.BodyRegion.IsInside(caretLine, caretColumn) && (callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingMember.Name) || // For constructor definition, the expression is the constructor name (e.g. "MyClass") but the name of the member is "#ctor" (callingMember.Name == "#ctor" && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingClass.Name)) ) ) { return(new MemberResolveResult(callingClass, callingMember, callingMember)); } } return(null); }
public static ResolveResult GetResultFromDeclarationLine(IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, ExpressionResult expressionResult) { try { string expression = expressionResult.Expression; if (callingClass == null) { return(null); } int pos = expression.IndexOf('('); if (pos >= 0) { expression = expression.Substring(0, pos); } expression = expression.Trim(); // if (!callingClass.BodyRegion.IsInside(caretLine, caretColumn) // && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingClass.Name)) // { // return new TypeResolveResult(callingClass, callingMember, callingClass); // } if (expressionResult.Context != ExpressionContext.Type) { if (callingMember != null && !callingMember.BodyRegion.IsInside(caretLine, caretColumn) && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingMember.Name)) { return(new MemberResolveResult(callingClass, callingMember, callingMember)); } } } catch (Exception ex) { PublicDI.log.ex(ex, "in CtrlSpaceResolverHelper.GetResultFromDeclarationLine"); } return(null); }