Пример #1
0
            public override AstVisitAction VisitTypeDefinition(TypeDefinitionAst typeDefinitionAst)
            {
                // Look for 'class MyClass { ... }' and 'enum MyEnum { ... }' definitions

                if (!_targetVersions.Contains(s_v3) && !_targetVersions.Contains(s_v4))
                {
                    return(AstVisitAction.Continue);
                }

                string message = string.Format(
                    CultureInfo.CurrentCulture,
                    Strings.UseCompatibleSyntaxError,
                    "type definition",
                    "class MyClass { ... } | enum MyEnum { ... }",
                    "3,4");

                _diagnosticAccumulator.Add(
                    new DiagnosticRecord(
                        message,
                        typeDefinitionAst.Extent,
                        _rule.GetName(),
                        _rule.Severity,
                        _analyzedFilePath
                        ));

                return(AstVisitAction.Continue);
            }
            public override AstVisitAction VisitMemberExpression(MemberExpressionAst memberExpressionAst)
            {
                if (!_targetVersions.Contains(s_v3))
                {
                    return(AstVisitAction.Continue);
                }

                if (!(memberExpressionAst.Member is StringConstantExpressionAst))
                {
                    string message = string.Format(
                        CultureInfo.CurrentCulture,
                        Strings.UseCompatibleSyntaxError,
                        "dynamic member invocation",
                        memberExpressionAst.Extent.Text,
                        "3");

                    _diagnosticAccumulator.Add(new DiagnosticRecord(
                                                   message,
                                                   memberExpressionAst.Extent,
                                                   _rule.GetName(),
                                                   _rule.Severity,
                                                   _analyzedFilePath
                                                   ));
                }

                return(AstVisitAction.Continue);
            }
Пример #3
0
            public override AstVisitAction VisitInvokeMemberExpression(InvokeMemberExpressionAst methodCallAst)
            {
                // Look for [typename]::new(...) and [typename]::$dynamicMethodName syntax

                if (!_targetVersions.Contains(s_v3) && !_targetVersions.Contains(s_v4))
                {
                    return(AstVisitAction.Continue);
                }

                if (_targetVersions.Contains(s_v3) && methodCallAst.Member is VariableExpressionAst)
                {
                    string message = string.Format(
                        CultureInfo.CurrentCulture,
                        Strings.UseCompatibleSyntaxError,
                        "dynamic method invocation",
                        methodCallAst.Extent.Text,
                        "3");

                    _diagnosticAccumulator.Add(new DiagnosticRecord(
                                                   message,
                                                   methodCallAst.Extent,
                                                   _rule.GetName(),
                                                   _rule.Severity,
                                                   _analyzedFilePath
                                                   ));
                }

                if (!(methodCallAst.Expression is TypeExpressionAst typeExpressionAst))
                {
                    return(AstVisitAction.Continue);
                }

                if (!(methodCallAst.Member is StringConstantExpressionAst stringConstantAst))
                {
                    return(AstVisitAction.Continue);
                }

                if (stringConstantAst.Value.Equals("new", StringComparison.OrdinalIgnoreCase))
                {
                    string typeName = typeExpressionAst.TypeName.FullName;

                    CorrectionExtent suggestedCorrection = CreateNewObjectCorrection(
                        _analyzedFilePath,
                        methodCallAst.Extent,
                        typeName,
                        methodCallAst.Arguments);

                    string message = string.Format(
                        CultureInfo.CurrentCulture,
                        Strings.UseCompatibleSyntaxError,
                        "constructor",
                        methodCallAst.Extent.Text,
                        "3,4");

                    _diagnosticAccumulator.Add(new DiagnosticRecord(
                                                   message,
                                                   methodCallAst.Extent,
                                                   _rule.GetName(),
                                                   _rule.Severity,
                                                   _analyzedFilePath,
                                                   ruleId: null,
                                                   suggestedCorrections: new [] { suggestedCorrection }
                                                   ));

                    return(AstVisitAction.Continue);
                }

                return(AstVisitAction.Continue);
            }