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);
        }
Ejemplo n.º 2
0
        /// <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);
		}
Ejemplo n.º 5
0
		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;
		}
Ejemplo n.º 6
0
		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);
		}
Ejemplo n.º 13
0
		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;
		}
Ejemplo n.º 15
0
		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;
		}
Ejemplo n.º 18
0
		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;
		}
Ejemplo n.º 20
0
		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);
		}
Ejemplo n.º 21
0
		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);
		}
Ejemplo n.º 24
0
		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);
		}
Ejemplo n.º 28
0
        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); });
		}
Ejemplo n.º 30
0
		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;
		}
Ejemplo n.º 31
0
 /// <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;
		}
Ejemplo n.º 34
0
        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;
        }
Ejemplo n.º 36
0
        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);
        }
Ejemplo n.º 37
0
 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);
 }