public override void VisitInvocationExpression(IInvocationExpression invocation, IHighlightingConsumer consumer) { if (IsCallWithTheSameContextAsFunctionOwner(invocation)) consumer.AddHighlighting(new CallWithSameContextWarning(invocation), invocation.GetHighlightingRange(), File); base.VisitInvocationExpression(invocation, consumer); }
public override void VisitNode(ITreeNode element, IHighlightingConsumer consumer) { var tokenNode = element as ITokenNode; if (tokenNode != null && tokenNode.GetTokenType().IsWhitespace) return; var colorInfo = CreateColorHighlightingInfo(element); if (colorInfo != null) consumer.AddHighlighting(colorInfo.Highlighting, colorInfo.Range); }
private void AddHighLighting(DocumentRange range, ITreeNode element, IHighlightingConsumer consumer, IHighlighting highlighting) { var info = new HighlightingInfo(range, highlighting, new Severity?()); IFile file = element.GetContainingFile(); if (file != null) { consumer.AddHighlighting(info.Highlighting, file); } }
private void AddFactsSuggestionHighlighting( IHighlightingConsumer consumer, string message, IFact startElement, IFact endElement) { var highlighting = new HintRangeHighlighting<IFact>(startElement, endElement, message); IFile file = startElement.GetContainingFile(); if (file != null) { consumer.AddHighlighting(highlighting, file); } }
public override void VisitNode(ITreeNode node, IHighlightingConsumer context) { base.VisitNode(node, context); DocumentRange highlightingRange = node.GetHighlightingRange(); //context.AddHighlighting(new PredefinedHighlighting(VsPredefinedHighlighterIds.RazorCode), highlightingRange); string attributeId = GetHighlightingAttributeId(node); if (attributeId != null) context.AddHighlighting(new PredefinedHighlighting(attributeId, highlightingRange)); }
/// <summary> /// Visits the element. /// </summary> /// <param name="element">The param.</param> /// <param name="consumer">The context.</param> /// <returns></returns> public override object VisitElement(IElement element, IHighlightingConsumer consumer) { var tokenType = element as ITokenNode; if (tokenType != null) { AddHighlighting(consumer, this.stringEmptyAnalyzer.Analyze(tokenType)); } return base.VisitElement(element, consumer); }
public void VisitLeaf(ITreeNode treeNode, IHighlightingConsumer consumer) { ICollection<DocumentRange> colorConstantRange = treeNode.UserData.GetData(Constants.Ranges); if (colorConstantRange == null) return; colorConstantRange.ForEach( range => AddHighLighting(range, consumer, new TokenHighlighting(treeNode))); }
public ExceptionalDaemonStageProcess(ICSharpFile file, IContextBoundSettingsStore settings) : base(ServiceLocator.Process, file) { _settings = settings; #if R2016_1 || R2016_2 _consumer = new FilteringHighlightingConsumer(this, _settings, file); #else _consumer = new DefaultHighlightingConsumer(this, _settings); #endif }
public override void VisitStatement(IStatement statementParam, IHighlightingConsumer consumer) { var canBeSimplified = statementParam.FactsEnumerable.GroupBy(x => x.Predicate.GetText()).Any(x => x.Count() >= 2); if (canBeSimplified) { this.AddFactsSuggestionHighlighting( consumer, "Facts can be simplified", statementParam.FactsEnumerable.First(), statementParam.FactsEnumerable.Last()); } }
public override void VisitRuleDeclaredName(IRuleDeclaredName ruleDeclaredName, IHighlightingConsumer consumer) { string name = ruleDeclaredName.GetText(); if (myDeclarations.ContainsKey(name)) { List<IDeclaration> list = myDeclarations.GetValue(name); if (list.Count > 1) { consumer.AddHighlighting(new DuplicatingLocalDeclarationError(ruleDeclaredName), File); } } base.VisitRuleDeclaredName(ruleDeclaredName, consumer); }
public override void VisitNode(ITreeNode node, IHighlightingConsumer consumer) { // Tree level highlighting // const string prefixHighlighting = HighlightingAttributeIds.NAMESPACE_IDENTIFIER_ATTRIBUTE; if (node is IPrefix || node is IPrefixName) { this.AddSyntaxHighlighting(consumer, node, prefixHighlighting); } else if (node is ILocalName) { this.AddSyntaxHighlighting(consumer, node, HighlightingAttributeIds.METHOD_IDENTIFIER_ATTRIBUTE); } else if (node is IVariableIdentifier) { this.AddSyntaxHighlighting(consumer, node, HighlightingAttributeIds.FIELD_IDENTIFIER_ATTRIBUTE); } else if (node is ITokenNode) { // Token level highlighting // var token = node as ITokenNode; if (token.GetTokenType().IsStringLiteral) { if (token.Parent is IDataLiteral && token.Parent.LastChild != token) { this.AddSyntaxHighlighting(consumer, node, VsPredefinedHighlighterIds.String); } else { this.AddSyntaxHighlighting(consumer, node, VsPredefinedHighlighterIds.String); } } else if (token.GetTokenType().IsComment) { this.AddSyntaxHighlighting(consumer, node, VsPredefinedHighlighterIds.Comment); } else if (token.GetTokenType().IsKeyword) { this.AddSyntaxHighlighting(consumer, node, VsPredefinedHighlighterIds.Keyword); } else if (token.GetTokenType().IsConstantLiteral) { //this.AddSyntaxHighlighting(consumer, node, VsPredefinedHighlighterIds.Literal); } else if (token.GetTokenType() == NTriplesTokenType.NAMESPACE_SEPARATOR) { this.AddSyntaxHighlighting(consumer, node, prefixHighlighting); } } }
public override void VisitRuleDeclaration(IRuleDeclaration ruleDeclaration, IHighlightingConsumer consumer) { IRuleBody body = ruleDeclaration.Body; ITreeNode child = PsiTreeUtil.GetFirstChild<IRuleName>(body); var ruleName = child as IRuleName; if (ruleName != null) { if (ruleName.GetText().Equals(ruleDeclaration.DeclaredName)) { consumer.AddHighlighting(new LeftRecursionWarning(ruleName), File); } } base.VisitRuleDeclaration(ruleDeclaration, consumer); }
protected override void Run(IDllImportMethodDeclaration importMethod, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { var element = importMethod.MethodDeclaration; var libraryName = importMethod.ImportedDll; var factory = new LibraryFactory(); var library = factory.LoadLibrary(libraryName); var export = library[element.NameIdentifier.Name]; if (export == null || export.Parameters.Count != element.ParameterDeclarations.Count) { return; } for (var i = 0; i < element.ParameterDeclarations.Count; i++ ) { var parameter = element.ParameterDeclarations[i]; var knownParameter = export.Parameters[i]; var exportedType = new ClrTypeName(knownParameter.CLRType.FullName); if (parameter.Type.IsInt() && exportedType.Equals(IntPtrClrType)) { consumer.AddHighlighting(new DllImportInt32ForIntPtrHighlighting(parameter)); } var marshalAs = parameter.Attributes.GetAttibuteOfCLRType(MarshalAsAttribute); if (knownParameter.UnmanagedType.HasValue && marshalAs != null && marshalAs.ConstructorArgumentExpressions.Count == 1) { var argumentExpression = marshalAs.ConstructorArgumentExpressions[0]; if (!argumentExpression.IsConstantValue()) { continue; } var shortType = argumentExpression.ConstantValue.IsShort(); UnmanagedType unmanagedType; if (shortType) { unmanagedType = (UnmanagedType)(short)argumentExpression.ConstantValue.Value; } else { unmanagedType = (UnmanagedType)argumentExpression.ConstantValue.Value; } if (knownParameter.UnmanagedType.Value != unmanagedType) { consumer.AddHighlighting(new DllImportIncorrectParameterMarshalHighlighting(parameter, argumentExpression, knownParameter.UnmanagedType.Value)); } } } }
public override void VisitPsiExpression(IPsiExpression psiExpression, IHighlightingConsumer consumer) { ITreeNode child = psiExpression.FirstChild; IList<ISequence> list = new List<ISequence>(); while (child != null) { if (child is ISequence) { list.Add(child as ISequence); } if (child is IChoiceTail) { list.Add((child as IChoiceTail).Sequence); } child = child.NextSibling; } if (list.Count > 1) { ISequence[] sequences = list.ToArray(); var isRepeated = new bool[sequences.Count()]; for (int i = 0 ; i < sequences.Count() - 1 ; ++i) { if (!isRepeated[i]) { ISequence sequence1 = sequences[i]; for (int j = i + 1 ; j < sequences.Count() ; ++j) { ISequence sequence2 = sequences[j]; if (PsiTreeUtil.EqualsElements(sequence1, sequence2)) { if (!isRepeated[i]) { consumer.AddHighlighting(new RepeatedChoiceWarning(sequence1), File); isRepeated[i] = true; } consumer.AddHighlighting(new RepeatedChoiceWarning(sequence2), File); isRepeated[j] = true; } } } } } base.VisitPsiExpression(psiExpression, consumer); }
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); }
private void VisitLoop(ITreeNode loop, IHighlightingConsumer consumer) { var function = loop.GetContainingNode<IJsFunctionLike>(); var accessAnalizer = new VariableCollector(); loop.ProcessThisAndDescendants(accessAnalizer); var accessToExternalModifiedClosure = accessAnalizer.Variables .GroupBy(r => r.DeclaredElement) .Select(g => g.ToArray()) .Where(l => HasExternallyModifiedClosure(function, l)) .SelectMany(l => l) .Where(r => r.FunctionLike != function) .Select(info => info.Node); foreach (var expression in accessToExternalModifiedClosure) { consumer.AddHighlighting(new AccessToModifiedClosureWarning(expression), expression.GetHighlightingRange(), File); } }
public override void VisitClassDeclaration(IClassDeclaration classDeclarationParam, IHighlightingConsumer context) { base.VisitClassDeclaration(classDeclarationParam, context); if (!classDeclarationParam.IsSynthetic() || !T4CSharpCodeGenerator.ClassName.Equals(classDeclarationParam.DeclaredName, StringComparison.Ordinal)) return; IDeclaredTypeUsage superTypeUsage = classDeclarationParam.SuperTypeUsageNodes.FirstOrDefault(); if (superTypeUsage == null || T4CSharpCodeGenerator.DefaultBaseClassName.Equals(superTypeUsage.GetText(), StringComparison.Ordinal)) return; ITypeElement typeElement = CSharpTypeFactory.CreateDeclaredType(superTypeUsage).GetTypeElement(); if (typeElement == null) return; if (!typeElement.Methods.Any(IsTransformTextMethod)) context.AddHighlighting(new MissingTransformTextMethodHighlighting(superTypeUsage)); }
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 VisitSentences(ISentences sentencesParam, IHighlightingConsumer consumer) { string lastText = null; ISentence lastSentence = null; ISentence startSentence = null; const string message = "Statements can be simplified"; foreach (var sentence in sentencesParam.SentenceListEnumerable) { string text; if (sentence.Statement != null && sentence.Statement.Subject != null && !string.IsNullOrEmpty(text = sentence.Statement.Subject.GetText())) { if (text.Equals(lastText, StringComparison.Ordinal)) { if (startSentence == null) { startSentence = lastSentence; } } else { if (startSentence != null) { this.AddSentenceSuggestionHighlighting(consumer, message, startSentence, lastSentence); startSentence = null; } } lastSentence = sentence; lastText = text; } } if (startSentence != null) { this.AddSentenceSuggestionHighlighting(consumer, message, startSentence, lastSentence); } }
public override void VisitNode(ITreeNode node, IHighlightingConsumer consumer) { String s = node.GetText(); if (PsiLexer.IsKeyword(s)) { AddHighlighting(consumer, node); } else { var token = node as PsiGenericToken; if (token != null) { if (token.GetTokenType().IsStringLiteral) { AddHighlighting(consumer, new PsiStringLiteralHighlighting(node)); } else if (token.GetTokenType().IsComment) { AddHighlighting(consumer, new PsiCommentHighlighting(node)); } } } }
public override void VisitNode(ITreeNode node, IHighlightingConsumer consumer) { var element = node as IErrorElement; if (element != null) { if (element.GetTextLength() == 0) { ITreeNode parent = element.Parent; while ((parent != null) && (parent.GetTextLength() == 0)) { parent = parent.Parent; } if (parent != null) { this.AddHighlighting(consumer, parent); } } else { this.AddHighlighting(consumer, element); } } }
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)); } } }
protected override void Analyze(IInvocationExpression invocationExpression, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { if (!myAssetSerializationMode.IsForceText) { return; } if (!myUnityYamlSupport.IsParsingEnabled.Value) { return; } var argument = GetSceneNameArgument(invocationExpression); var literal = argument?.Value as ICSharpLiteralExpression; if (literal == null) { return; } if (invocationExpression.InvocationExpressionReference.IsSceneManagerSceneRelatedMethod()) { var cache = invocationExpression.GetSolution().TryGetComponent <UnityProjectSettingsCache>(); if (cache == null) { return; } var sceneName = GetScenePathFromArgument(literal); if (sceneName != null) { // check build settings warnings if (cache.IsScenePresentedAtEditorBuildSettings(sceneName, out var ambiguousDefinition)) { if (cache.IsSceneDisabledAtEditorBuildSettings(sceneName)) { consumer.AddHighlighting(new LoadSceneDisabledSceneNameWarning(argument, sceneName)); } else if (ambiguousDefinition) { consumer.AddHighlighting( new LoadSceneAmbiguousSceneNameWarning(argument, sceneName)); } } else { if (cache.IsSceneExists(sceneName)) { consumer.AddHighlighting(new LoadSceneUnknownSceneNameWarning(argument, sceneName)); } else { consumer.AddHighlighting(new LoadSceneUnexistingSceneNameWarning(argument)); } } } else if (literal.ConstantValue.IsInteger()) { var value = (int)literal.ConstantValue.Value; if (value >= cache.SceneCount) { consumer.AddHighlighting(new LoadSceneWrongIndexWarning(argument)); } } } if (invocationExpression.InvocationExpressionReference.IsEditorSceneManagerSceneRelatedMethod()) { var cache = invocationExpression.GetSolution().TryGetComponent <UnityProjectSettingsCache>(); if (cache == null) { return; } var sceneName = GetScenePathFromArgument(literal); if (sceneName != null) { if (!cache.IsSceneExists(sceneName)) { consumer.AddHighlighting(new LoadSceneUnexistingSceneNameWarning(argument)); } } } }
protected override void Analyze(INullCoalescingExpression expression, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { if (!(expression.LeftOperand is IReferenceExpression leftOperand) || expression.RightOperand == null) { return; } var resolve = leftOperand.Reference.Resolve(); if (resolve.ResolveErrorType != ResolveErrorType.OK) { return; } var unityObjectType = TypeFactory.CreateTypeByCLRName(KnownTypes.Object, expression.GetPsiModule()); if (!leftOperand.Type().IsSubtypeOf(unityObjectType)) { return; } consumer.AddHighlighting(new UnityObjectNullCoalescingWarning(expression)); }
protected override bool CheckAndAnalyze(IMethodDeclaration methodDeclaration, IHighlightingConsumer consumer, IReadOnlyCallGraphContext context) { return(false); }
public override void VisitExpressionStatementNode(IExpressionStatement expressionStatementParam, IHighlightingConsumer context) { if (expressionStatementParam.FirstChild is IIdentifier identifier) { context.AddHighlighting(new CgHighlighting(CgHighlightingAttributeIds.VARIABLE_IDENTIFIER, identifier.GetDocumentRange())); } base.VisitExpressionStatementNode(expressionStatementParam, context); }
protected override void Analyze(IJavaScriptLiteralExpression element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { if (element.IsReferencesStringLiteralValue()) { var nameCache = data.Solution.GetComponent <AsmDefNameCache>(); var nameDeclaredElement = nameCache.GetNameDeclaredElement(data.SourceFile); var reference = element.FindReference <AsmDefNameReference>(); if (reference != null && nameDeclaredElement != null && Equals(reference.Resolve().DeclaredElement, nameDeclaredElement)) { consumer.AddHighlighting(new ReferencingSelfError(reference)); } } }
protected override void Run(IStartRegion element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { if (element.EndRegion != null) { var nonWhitespaceNodes = 0; foreach (var node in TreeRange.Build(element, element.EndRegion).Skip(1).TakeWhile(n => n != element.EndRegion)) { if (node?.NodeType is TokenNodeType tokenNodeType && tokenNodeType.IsWhitespace) { continue; } nonWhitespaceNodes++; if (nonWhitespaceNodes > 1) { break; } } switch (nonWhitespaceNodes) { case 0: consumer.AddHighlighting(new EmptyRegionHighlighting("The region is empty.", element)); break; case 1: consumer.AddHighlighting(new RegionWithSingleElementHighlighting("The region contains a single element.", element)); break; } } if (element.GetContainingNode <IBlock>() != null) { consumer.AddHighlighting(new RegionWithinTypeMemberBodyHighlighting("The region is contained within a type member body.", element)); } }
protected override void Run( IInvocationExpression element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { var templateArgument = element.GetTemplateArgument(); if (templateArgument == null) { return; } var exceptionType = element.PsiModule.GetPredefinedType().TryGetType(PredefinedType.EXCEPTION_FQN, NullableAnnotation.Unknown); if (exceptionType == null) { return; } ICSharpArgument invalidExceptionArgument = FindInvalidExceptionArgument(element, templateArgument, exceptionType); if (invalidExceptionArgument == null) { return; } var overloadAvailable = false; var candidates = element.InvocationExpressionReference.GetCandidates().ToArray(); var invalidArgumentIndex = invalidExceptionArgument.IndexOf(); foreach (var candidate in candidates) { if (!(candidate.GetDeclaredElement() is IMethod declaredElement)) { continue; } foreach (var parameter in declaredElement.Parameters) { if (invalidArgumentIndex <= parameter.IndexOf()) { break; } if (parameter.Type.IsSubtypeOf(exceptionType)) { overloadAvailable = true; break; } } if (overloadAvailable) { break; } } if (!overloadAvailable) { return; } consumer.AddHighlighting(new ExceptionPassedAsTemplateArgumentWarning(invalidExceptionArgument.GetDocumentRange())); }
/// <summary> /// Adds the highlighting. /// </summary> /// <param name="consumer">The consumer.</param> /// <param name="suggestions">The suggestions.</param> private static void AddHighlighting(IHighlightingConsumer consumer, IEnumerable<SuggestionBase> suggestions) { if (suggestions == null) { return; } foreach (var highlighting in suggestions) { AddHighlighting(consumer, highlighting); } }
/// <summary> /// Visits the type member. /// </summary> /// <param name="typeMemberDeclaration">The type member declaration.</param> /// <param name="consumer">The consumer.</param> /// <returns></returns> private void VisitTypeMember(ITypeMemberDeclaration typeMemberDeclaration, IHighlightingConsumer consumer) { AddHighlighting(consumer, this.valueAnalysisAnalyzer.Analyze(typeMemberDeclaration)); }
protected override void Run( ICSharpFunctionDeclaration element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { if (element.Body == null) { return; } var elementProcessor = new CognitiveComplexityElementProcessor(element); element.Body.ProcessDescendants(elementProcessor); var store = data.SettingsStore; var baseThreshold = store.GetValue((CognitiveComplexityAnalysisSettings s) => s.CSharpThreshold); var complexityPercentage = (int)(elementProcessor.ComplexityScore * 100.0 / baseThreshold); if (complexityPercentage > 100) { consumer.AddHighlighting(new CognitiveComplexityErrorHighlighting( element, elementProcessor.ComplexityScore - baseThreshold, complexityPercentage)); } else { consumer.AddHighlighting(new CognitiveComplexityInfoHighlighting( element, elementProcessor.ComplexityScore, complexityPercentage)); } #if RIDER var lowThreshold = store.GetValue((CognitiveComplexityAnalysisSettings s) => s.LowComplexityThreshold); var middleThreshold = store.GetValue((CognitiveComplexityAnalysisSettings s) => s.MiddleComplexityThreshold); var highThreshold = store.GetValue((CognitiveComplexityAnalysisSettings s) => s.HighComplexityThreshold); string codeLensText; IconId iconId; if (complexityPercentage >= highThreshold) { iconId = ComplexityExtreme.Id; codeLensText = complexityPercentage >= highThreshold * 2 ? $"refactor me? ({complexityPercentage}%)" : $"very complex ({complexityPercentage}%)"; } else if (complexityPercentage >= middleThreshold) { iconId = ComplexityHigh.Id; codeLensText = $"mildly complex ({complexityPercentage}%)"; } else if (complexityPercentage >= lowThreshold) { iconId = ComplexityAverage.Id; codeLensText = $"simple enough ({complexityPercentage}%)"; } else { iconId = ComplexityLow.Id; codeLensText = string.Empty; } var moreText = $"Cognitive complexity value of {elementProcessor.ComplexityScore} " + $"({complexityPercentage}% of threshold {baseThreshold})"; consumer.AddHighlighting( new CodeInsightsHighlighting( element.GetNameDocumentRange(), codeLensText, moreText, moreText, _codeInsightsProvider, element.DeclaredElement, _iconHost.Transform(iconId)) ); if (elementProcessor.Complexities != null) { var min = int.MaxValue; var max = int.MinValue; foreach (var(_, _, complexity) in elementProcessor.Complexities) { min = Math.Min(min, complexity); max = Math.Max(max, complexity); } foreach (var(node, offset, complexity) in elementProcessor.Complexities) { if (complexityPercentage >= highThreshold && complexity == max) { consumer.AddHighlighting(new CognitiveComplexityErrorHint(node, offset, complexity)); } else if (complexityPercentage >= middleThreshold && complexity >= min + (max - min) / 2) { consumer.AddHighlighting(new CognitiveComplexityWarningHint(node, offset, complexity)); } else { consumer.AddHighlighting(new CognitiveComplexityInfoHint(node, offset, complexity)); } } } #endif }
public override void VisitNode(ITreeNode node, IHighlightingConsumer consumer) { myElementAnalyzerDispatcher.Run(node, consumer); }
private void HighlightNameNodes(IVariableDeclaration variableDeclaration, IHighlightingConsumer context, string highlightingAttributeId) { foreach (var name in variableDeclaration.NameNodes) { context.AddHighlighting(new CgHighlighting(highlightingAttributeId, name.GetDocumentRange())); } }
protected override void Run(IInvocationExpression element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { /* * this.WhenAnyValue( * x => x.Toggle, * x => _settingsProvider.Settings.IsAdmin, * (toggle, admin) => toggle && admin) * .ToProperty(this, nameof(ShowAdmin), out _showAdmin); */ var method = element.InvocationExpressionReference.Resolve().DeclaredElement as IMethod; if (method?.ShortName != "WhenAnyValue") { return; } var typeByClrName = TypeFactory.CreateTypeByCLRName("ReactiveUI.WhenAnyMixin", element.PsiModule); if (method.GetContainingType()?.Equals(typeByClrName.GetTypeElement()) ?? true) { return; } foreach (var argument in element.ArgumentsEnumerable) { // A.B.C // -> A.B // -> A var lambdaExpression = argument.Expression as ILambdaExpression; var referenceExpression = lambdaExpression?.BodyExpression as IReferenceExpression; var qualifierExpression = referenceExpression?.TraverseAcross(x => x.QualifierExpression as IReferenceExpression) .Last(); // var qualifierExpression = referenceExpression.QualifierExpression as IReferenceExpression; if (qualifierExpression == null) { continue; } var parameter = lambdaExpression.ParameterDeclarations.FirstOrDefault(); if (parameter == null) { continue; } if (parameter.NameIdentifier.Name == qualifierExpression.NameIdentifier.Name) { continue; } var field = qualifierExpression.Reference.Resolve().DeclaredElement as IField; var type = field?.GetContainingType(); // if (type?.GetClrName().FullName != (parameter.DeclaredElement.Type as IDeclaredType)?.GetClrName().FullName) if (!type?.Equals((parameter.DeclaredElement.Type as IDeclaredType)?.GetTypeElement()) ?? true) { continue; } consumer.AddHighlighting(new SampleHighlighting(lambdaExpression)); } }
protected override void Run(IReferenceExpression element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { if (element.QualifierExpression != null && !element.HasConditionalAccessSign && element.Reference.Resolve().DeclaredElement.IsDelegateInvokeMethod() && element.GetNextMeaningfulSibling() is CSharpTokenBase token && token.GetTokenType() == CSharpTokenType.LPARENTH) { consumer.AddHighlighting(new RedundantDelegateInvokeHighlighting($"Redundant '{nameof(Action.Invoke)}' expression.", element)); } }
protected override void Run(ISpecificCatchClause element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { if (element.ExceptionType.ToString() == "System.Exception" && element.ExceptionDeclaration == null) { consumer.AddHighlighting(new CatchClauseWithoutVariableSuggestion("Redundant declaration without exception variable.", element)); } }
protected override void Analyze(IAttribute attribute, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { if (!(attribute.TypeReference?.Resolve().DeclaredElement is ITypeElement attributeTypeElement)) { return; } if (!Equals(attributeTypeElement.GetClrName(), KnownTypes.HideInInspector)) { return; } var fields = attribute.GetFieldsByAttribute(); foreach (var field in fields) { if (!Api.IsSerialisedField(field)) { consumer.AddHighlighting(new RedundantHideInInspectorAttributeWarning(attribute)); return; } } }
protected virtual void AddHighlighting(IHighlightingConsumer consumer, ICSharpDeclaration element, string text, string tooltip, DaemonProcessKind kind) { consumer.AddImplicitConfigurableHighlighting(element); consumer.AddHotHighlighting(CallGraphSwaExtensionProvider, element, MarksProvider, Settings, text, tooltip, kind, GetActions(element), myProvider); }
protected override void Run(ICSharpTreeNode element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { IExpressionType exceptionType; switch (element) { case IThrowStatement throwStatement: exceptionType = throwStatement.Exception?.GetExpressionType(); break; case IThrowExpression throwExpression: exceptionType = throwExpression.Exception?.GetExpressionType(); break; default: return; } if (exceptionType == null) { return; } var location = TryGetLocation(element, data); if (location != null) { if (GetAllowedExceptions((Location)location, element.GetPsiModule()).Any(e => IsOrDerivesFrom(exceptionType, e))) { return; } consumer.AddHighlighting( new ThrowExceptionInUnexpectedLocationWarning($"Exceptions should never be thrown in {GetText((Location)location)}.", element)); } }
public abstract bool AddDeclarationHighlighting(IDeclaration treeNode, IHighlightingConsumer consumer, DaemonProcessKind kind);
protected override void Analyze(IInvocationExpression element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { if (!myAssetSerializationMode.IsForceText) { return; } if (!myUnityYamlSupport.IsParsingEnabled.Value) { return; } if (element.IsLayerMaskGetMaskMethod() || element.IsLayerMaskNameToLayerMethod()) { foreach (var argument in element.ArgumentList.Arguments) { var literal = (argument?.Value as ICSharpLiteralExpression)?.ConstantValue.Value as string; if (literal == null) { return; } var cache = element.GetSolution().TryGetComponent <UnityProjectSettingsCache>(); if (cache != null && !cache.HasLayer(literal)) { consumer.AddHighlighting(new UnknownLayerWarning(argument)); } } } }
public override void VisitFieldOperatorNode(IFieldOperator fieldOperatorParam, IHighlightingConsumer context) { context.AddHighlighting(new CgHighlighting(CgHighlightingAttributeIds.FIELD_IDENTIFIER, fieldOperatorParam.FieldNode.GetDocumentRange())); base.VisitFieldOperatorNode(fieldOperatorParam, context); }
public override void VisitClassDeclaration(IClassDeclaration classDeclarationParam, IHighlightingConsumer context) { base.VisitClassDeclaration(classDeclarationParam, context); if (!classDeclarationParam.IsSynthetic() || !T4CSharpCodeGenerator.ClassName.Equals(classDeclarationParam.DeclaredName, StringComparison.Ordinal)) { return; } IDeclaredTypeUsage superTypeUsage = classDeclarationParam.SuperTypeUsageNodes.FirstOrDefault(); if (superTypeUsage == null || T4CSharpCodeGenerator.DefaultBaseClassName.Equals(superTypeUsage.GetText(), StringComparison.Ordinal)) { return; } ITypeElement typeElement = CSharpTypeFactory.CreateDeclaredType(superTypeUsage).GetTypeElement(); if (typeElement == null) { return; } if (!typeElement.Methods.Any(IsTransformTextMethod)) { context.AddHighlighting(new MissingTransformTextMethodHighlighting(superTypeUsage)); } }
protected sealed override void Run(T element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { var processKind = data.GetDaemonProcessKind(); if (processKind != DaemonProcessKind.VISIBLE_DOCUMENT) { return; } Analyze(element, data, consumer); }
public override void VisitPostfixExpressionNode(IPostfixExpression postfixExpressionParam, IHighlightingConsumer context) { if (postfixExpressionParam.OperatorNode.FirstOrDefault() is ICallOperator && postfixExpressionParam.OperandNode is IIdentifier functionName) { context.AddHighlighting(new CgHighlighting(CgHighlightingAttributeIds.FUNCTION_IDENTIFIER, functionName.GetDocumentRange())); } base.VisitPostfixExpressionNode(postfixExpressionParam, context); }
/// <summary> /// Visits the throw statement. /// </summary> /// <param name="throwStatement">The throw statement.</param> /// <param name="consumer">The consumer.</param> /// <returns></returns> public override object VisitThrowStatement(IThrowStatement throwStatement, IHighlightingConsumer consumer) { AddHighlighting(consumer, this.documentThrownExceptionAnalyzer.AnalyzeThrowStatement(throwStatement)); return base.VisitThrowStatement(throwStatement, consumer); }
public GlobalProcessor(PsiDaemonStageProcessBase process, IHighlightingConsumer consumer) : base(process, consumer) { }
/// <summary> /// Adds the highlighting. /// </summary> ///<param name="consumer">The consumer.</param> ///<param name="highlighting">The highlighting.</param> private static void AddHighlighting(IHighlightingConsumer consumer, SuggestionBase highlighting) { var range = highlighting.Range; if (!range.IsValid()) { return; } consumer.AddHighlighting(range, highlighting); }
public BurstProblemSubAnalyzerStatus CheckAndAnalyze(IReferenceExpression referenceExpression, IHighlightingConsumer consumer) { var element = referenceExpression.Reference.Resolve().DeclaredElement; if (!(element is ITypeOwner typeOwner)) { return(BurstProblemSubAnalyzerStatus.NO_WARNING_CONTINUE); } if (typeOwner is IAttributesOwner attributesOwner && attributesOwner.HasAttributeInstance(KnownTypes.NativeSetClassTypeToNullOnScheduleAttribute, AttributesSource.Self)) { return(BurstProblemSubAnalyzerStatus.NO_WARNING_CONTINUE); } if (BurstCodeAnalysisUtil.IsBurstPermittedType(typeOwner.Type())) { return(BurstProblemSubAnalyzerStatus.NO_WARNING_CONTINUE); } consumer?.AddHighlighting(new BurstLoadingManagedTypeWarning( referenceExpression, typeOwner.Type().GetTypeElement()?.ShortName)); return(BurstProblemSubAnalyzerStatus.WARNING_PLACED_STOP); }
/// <summary> /// Visits the constructor declaration. /// </summary> /// <param name="constructorDeclaration">The constructor declaration.</param> /// <param name="consumer">The consumer.</param> /// <returns></returns> public override object VisitConstructorDeclaration(IConstructorDeclaration constructorDeclaration, IHighlightingConsumer consumer) { this.VisitTypeMember(constructorDeclaration, consumer); return base.VisitConstructorDeclaration(constructorDeclaration, consumer); }
public override void VisitStructDeclarationNode(IStructDeclaration structDeclarationParam, IHighlightingConsumer context) { context.AddHighlighting(new CgHighlighting(CgHighlightingAttributeIds.TYPE_IDENTIFIER, structDeclarationParam.NameNode.GetDocumentRange())); base.VisitStructDeclarationNode(structDeclarationParam, context); }
public override void VisitRuleDeclaredName(IRuleDeclaredName ruleDeclaredName, IHighlightingConsumer consumer) { DocumentRange colorConstantRange = ruleDeclaredName.GetDocumentRange(); AddHighLighting(colorConstantRange, ruleDeclaredName, consumer, new PsiRuleHighlighting(ruleDeclaredName)); base.VisitRuleDeclaredName(ruleDeclaredName, consumer); }
public override void VisitFunctionDeclarationNode(IFunctionDeclaration functionDeclarationParam, IHighlightingConsumer context) { var header = functionDeclarationParam.HeaderNode; if (header.TypeNode is IIdentifier userDeclaredType) { context.AddHighlighting(new CgHighlighting(CgHighlightingAttributeIds.TYPE_IDENTIFIER, userDeclaredType.GetDocumentRange())); } try { context.AddHighlighting(new CgHighlighting(CgHighlightingAttributeIds.FUNCTION_IDENTIFIER, header.NameNode.GetDocumentRange())); } catch (InvalidCastException ex) { // TODO: remove after PP implementation myLogger.LogExceptionSilently(ex); } base.VisitFunctionDeclarationNode(functionDeclarationParam, context); }
public static void AddImplicitConfigurableHighlighting(this IHighlightingConsumer consumer, ICSharpDeclaration declaration) { consumer.AddHighlighting(new UnityImplicitlyUsedIdentifierHighlighting(declaration.NameIdentifier.GetDocumentRange())); }
private void CreateHiglighting(IInvocationExpression expression, IHighlightingConsumer consumer) { consumer.AddHighlighting(new UnityPerformanceInvocationWarning(expression, (expression.InvokedExpression as IReferenceExpression)?.Reference)); }
public override void VisitVariableDeclarationNode(IVariableDeclaration variableDeclarationParam, IHighlightingConsumer context) { HighlightNameNodes(variableDeclarationParam, context, CgHighlightingAttributeIds.VARIABLE_IDENTIFIER); base.VisitVariableDeclarationNode(variableDeclarationParam, context); }
protected override void Run(IInvocationExpression element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { var conditions = GetConditionsIfConditionalMethodInvoked(element); if (conditions.Count > 0) { consumer.AddHighlighting( new ConditionalInvocationHighlighting( conditions.Count == 1 ? string.Format("Method invocation will be skipped if the '{0}' condition is not defined.", conditions[0]) : string.Format( "Method invocation will be skipped if none of the following conditions is defined: {0}.", string.Join(", ", from condition in conditions orderby condition select $"'{condition}'")), element)); } }
protected ProcessorBase(PsiDaemonStageProcessBase process, IHighlightingConsumer consumer) { myProcess = process; myConsumer = consumer; }
public override void VisitFieldDeclarationNode(IFieldDeclaration fieldDeclarationParam, IHighlightingConsumer context) { var variableDeclaration = fieldDeclarationParam.ContentNode; if (variableDeclaration != null) { HighlightNameNodes(variableDeclaration, context, CgHighlightingAttributeIds.FIELD_IDENTIFIER); } base.VisitFieldDeclarationNode(fieldDeclarationParam, context); }