public override Boolean IsAvailable(IUserDataHolder cache) { ResolveResultWithInfo resolve_result_with_info = this.error.Reference.Resolve(); Boolean is_available = resolve_result_with_info.DeclaredElement is IMethod || resolve_result_with_info.DeclaredElement is IConstructor; return(is_available); }
private static FileSystemPath GetBasePathBeforeMapping(IQualifiableReference pathReference) { IQualifier qualifier = pathReference.GetQualifier(); if (qualifier == null) { IProjectFile file = pathReference.GetTreeNode().GetSourceFile().ToProjectFile(); Assertion.AssertNotNull(file, "file == null"); return(file.Location.Directory); } var reference = qualifier as IReference; if (reference != null) { ResolveResultWithInfo resolveResultWithInfo = (reference).Resolve(); var pathDeclaredElement = resolveResultWithInfo.DeclaredElement as IPathDeclaredElement; if (pathDeclaredElement == null) { return(FileSystemPath.Empty); } return(pathDeclaredElement.Path); } var pathQualifier = qualifier as IPathQualifier; if (pathQualifier != null) { return(pathQualifier.Path); } return(FileSystemPath.Empty); }
public override ResolveResultWithInfo GetResolveResult(ISymbolTable symbolTable, string referenceName) { ResolveResultWithInfo resolveResult = LocalResolveWithoutCache(); resolveResult = new ResolveResultWithInfo(resolveResult.Result, GetResolveInfo(resolveResult.Info)); return(resolveResult); }
public override MethodInvocation ProcessUsage(IReference reference) { var referenceExpression = reference.GetTreeNode() as IReferenceExpression; if (referenceExpression == null) { Driver.AddConflict(ReferenceConflict.CreateError(reference, "{0} can not be updated correctly.", "Usage")); return(null); } bool isExtensionMethod = referenceExpression.IsExtensionMethod(); IInvocationExpression invocation = InvocationExpressionNavigator.GetByInvokedExpression(referenceExpression); if (invocation == null) { Driver.AddConflict(ReferenceConflict.CreateError(reference, "{0} can not be updated correctly.", "Usage")); return(null); } ITreeNode element = GetArgument(invocation, isExtensionMethod); var argument = element as ICSharpArgument; IType type = argument != null?GetTypeOfValue(argument.Value) : GetTypeOfValue(element); if (type == null || !type.CanUseExplicitly(invocation)) { Driver.AddConflict(ReferenceConflict.CreateError( reference, "Argument of {0} is not valid 'typeof' expression.", "usage")); return(null); } // we can rely on resolve result since method declaration is not yet changed. ResolveResultWithInfo resolveResult = reference.Resolve(); ISubstitution substitution = resolveResult.Result.Substitution; var method = resolveResult.DeclaredElement as IMethod; if (method == null) { return(null); } if (argument != null) { invocation.RemoveArgument(argument); return(new MethodInvocation(reference, type, method, substitution)); } CSharpElementFactory factory = CSharpElementFactory.GetInstance(invocation.GetPsiModule()); IReferenceExpression newInvokedExpression = invocation.InvokedExpression.ReplaceBy(factory.CreateReferenceExpression("$0", Executer.Method)); return(new MethodInvocation(newInvokedExpression.Reference, type, method, substitution)); }
protected override void AppendTooltip(AttributeNameExpectedError highlighting, CSharpColorizer colorizer) { ResolveResultWithInfo resolveResult = highlighting.Reference.Resolve(); IDeclaredElement declaredElement = resolveResult.DeclaredElement; if (declaredElement == null) { return; } colorizer.AppendPlainText("'"); colorizer.AppendDeclaredElement(declaredElement, resolveResult.Substitution, PresenterOptions.NameOnly, highlighting.Reference.GetTreeNode()); colorizer.AppendPlainText("' is not an attribute"); }
public override void VisitStateName(IStateName stateNameParam, IHighlightingConsumer consumer) { DocumentRange colorConstantRange = stateNameParam.GetDocumentRange(); ResolveResultWithInfo resolve = stateNameParam.StateNameReference.Resolve(); if ((resolve == null) || ((resolve.Result.DeclaredElement == null) && (resolve.Result.Candidates.Count == 0))) { AddHighLighting(colorConstantRange, stateNameParam, consumer, new LexUnresolvedStateHighlighting(stateNameParam)); } else { AddHighLighting(colorConstantRange, stateNameParam, consumer, new LexStateHighlighting(stateNameParam)); } base.VisitStateName(stateNameParam, consumer); }
protected override void AppendTooltip(AccessRightsInTextWarning highlighting, CSharpColorizer colorizer) { ResolveResultWithInfo resolveResult = highlighting.Reference.Resolve(); if (resolveResult.DeclaredElement is not { } declaredElement) { return; } colorizer.AppendPlainText("Cannot access "); colorizer.AppendElementKind(declaredElement); colorizer.AppendPlainText(" '"); colorizer.AppendDeclaredElement(declaredElement, resolveResult.Substitution, PresenterOptions.NameOnly, highlighting.Reference.GetTreeNode()); colorizer.AppendPlainText("' here"); }
protected override void AppendTooltip(CannotCreateInstanceOfInterfaceError highlighting, CSharpColorizer colorizer) { ResolveResultWithInfo resolveResult = highlighting.ReferenceName.Reference.Resolve(); IDeclaredElement declaredElement = resolveResult.DeclaredElement; colorizer.AppendPlainText("Cannot create an instance of the interface '"); if (declaredElement != null) { colorizer.AppendDeclaredElement(declaredElement, resolveResult.Substitution, PresenterOptions.QualifiedName, highlighting.ReferenceName); } else { colorizer.AppendInterfaceName(highlighting.ReferenceName.GetText()); } colorizer.AppendPlainText("'"); }
public override void VisitVariableName(IVariableName variableNameParam, IHighlightingConsumer consumer) { DocumentRange colorConstantRange = variableNameParam.GetDocumentRange(); var variableName = variableNameParam as VariableName; if (variableName != null) { ResolveResultWithInfo resolve = variableName.Resolve(); if ((resolve != null) && ((resolve.Result.DeclaredElement != null) || (resolve.Result.Candidates.Count > 0))) { AddHighLighting(colorConstantRange, variableNameParam, consumer, new PsiVariableHighlighting(variableNameParam)); } else { AddHighLighting(colorConstantRange, variableNameParam, consumer, new PsiUnresolvedVariableReferenceHighlighting(variableName)); } } }
public override void VisitPathName(IPathName pathNameParam, IHighlightingConsumer consumer) { DocumentRange colorConstantRange = pathNameParam.GetDocumentRange(); var pathName = pathNameParam as PathName; if (pathName != null) { ResolveResultWithInfo resolve = pathName.Resolve(); if ((resolve != null) && ((resolve.Result.DeclaredElement != null) || (resolve.Result.Candidates.Count > 0))) { AddHighLighting(colorConstantRange, pathNameParam, consumer, new PsiRuleHighlighting(pathNameParam)); } else { AddHighLighting(colorConstantRange, pathNameParam, consumer, new PsiUnresolvedPathReferenceHighlighting(pathName)); } } }
public override void VisitRuleName(IRuleName ruleName, IHighlightingConsumer consumer) { DocumentRange colorConstantRange = ruleName.GetDocumentRange(); ResolveResultWithInfo resolve = ruleName.RuleNameReference.Resolve(); bool isRuleResolved = resolve.Result.DeclaredElement != null || (resolve.Result.Candidates.Count > 0); if (isRuleResolved) { AddHighLighting(colorConstantRange, ruleName, consumer, new PsiRuleHighlighting(ruleName)); } else { AddHighLighting(colorConstantRange, ruleName, consumer, new PsiUnresolvedRuleReferenceHighlighting(ruleName)); } base.VisitRuleName(ruleName, consumer); }
public override void VisitPrefix(IPrefix prefixParam, IHighlightingConsumer consumer) { DocumentRange range = prefixParam.GetDocumentRange(); var prefix = prefixParam as Prefix; if (prefix != null) { ResolveResultWithInfo resolve = prefix.Resolve(); if (resolve == null || resolve.Result.DeclaredElement is UnresolvedNamespacePrefixDeclaredElement || ((resolve.Result.DeclaredElement == null) && (resolve.Result.Candidates.Count == 0))) { this.AddHighLighting( range, prefixParam, consumer, new NTriplesUnresolvedReferenceHighlighting <NTriplesPrefixReference>( prefix, prefix.PrefixReference, string.Format("Unresolved prefix '{0}'", prefix.GetText()))); } } }
public override void VisitNode(ITreeNode element, IHighlightingConsumer consumer) { DocumentRange colorConstantRange = element.GetDocumentRange(); if ((element is ITokenNode) && ((ITokenNode)element).GetTokenType().IsWhitespace) { return; } var variableName = element as VariableName; if (variableName != null) { ResolveResultWithInfo resolve = variableName.Resolve(); if ((resolve != null) && ((resolve.Result.DeclaredElement != null) || (resolve.Result.Candidates.Count > 0))) { AddHighLighting(colorConstantRange, element, consumer, new PsiVariableHighlighting(element)); } else { AddHighLighting(colorConstantRange, element, consumer, new PsiUnresolvedVariableReferenceHighlighting(variableName)); return; } } var pathName = element as PathName; if (pathName != null) { ResolveResultWithInfo resolve = pathName.Resolve(); if ((resolve != null) && ((resolve.Result.DeclaredElement != null) || (resolve.Result.Candidates.Count > 0))) { AddHighLighting(colorConstantRange, element, consumer, new PsiRuleHighlighting(element)); } else { AddHighLighting(colorConstantRange, element, consumer, new PsiUnresolvedPathReferenceHighlighting(pathName)); } } }
private static bool AttributeMatchedReflectionType([NotNull] IAttribute x, [NotNull] Type reflectionType) { if (x.Name.QualifiedName != reflectionType.Name.RemoveEnd(AttributePostfix)) { return(false); } ResolveResultWithInfo resolveResultWithInfo = x.Name.Reference.Resolve(); if (!resolveResultWithInfo.IsValid()) { return(false); } INamespace attributeNamespace = (resolveResultWithInfo.DeclaredElement as IClass)?.GetContainingNamespace(); if (attributeNamespace == null) { return(false); } return(attributeNamespace.QualifiedName == reflectionType.Namespace); }
public override Expression VisitReferenceExpression(IReferenceExpression referenceExpressionParam, IMetadataResolver context) { if (referenceExpressionParam.QualifierExpression != null) { Expression qualifierExpression = referenceExpressionParam.QualifierExpression.Accept(this, context); var invocationExpression = referenceExpressionParam.Parent as IInvocationExpression; if (invocationExpression != null) { IEnumerable <Expression> arguments = invocationExpression.ArgumentList.Arguments.Select( argument => argument.Accept(this, context)); return(new MethodCallExpressionBuilder(referenceExpressionParam, qualifierExpression, arguments, context).Build()); } return(new MemberReferenceExpressionBuilder(referenceExpressionParam, qualifierExpression, context).Build()); } ResolveResultWithInfo resolve = referenceExpressionParam.Reference.Resolve(); var lambdaParameterDeclaration = resolve.DeclaredElement as ILambdaParameterDeclaration; if (lambdaParameterDeclaration != null) { return(lambdaParameters.First( parameter => parameter.Name.Equals(lambdaParameterDeclaration.NameIdentifier.GetText()))); } var parameterDeclaration = resolve.DeclaredElement as IParameterDeclaration; if (parameterDeclaration != null) { return(new ParameterExpressionBuilder(parameterDeclaration, context).Build()); } return(base.VisitReferenceExpression(referenceExpressionParam, context)); }
private static IType GetClosedType(ResolveResultWithInfo resolveResultWithInfo, IType returnType) { var closedType = resolveResultWithInfo.Result.Substitution.Apply(returnType); return(closedType); }
public ReflectedMemberReference([NotNull] IExpression owner, ResolveResultWithInfo resolveResult, ITypeElement typeElement) : base(owner) { _resolveResult = resolveResult; _typeElement = typeElement; }