public override void VisitError(RazorError err) {
     base.VisitError(err);
     if (_errorList == null) {
         _errorList = new List<RazorError>();
     }
     _errorList.Add(err);
 }

        public RazorPadRazorError(RazorError error)
        {
            if (error == null)
                return;

            Column = error.Location.CharacterIndex;
            Line = error.Location.LineIndex;
            Message = error.Message;
        }

        public override void VisitError(RazorError err)
        {
            err.ThrowIfNull("err");

            if (_throwExceptionOnParserError)
            {
                throw new TemplateParsingException(err);
            }
        }

 public void ParseBlockMethodParsesNullConditionalOperatorImplicitExpression_Bracket(
     string implicitExpresison,
     string expectedImplicitExpression,
     AcceptedCharacters acceptedCharacters,
     RazorError[] expectedErrors)
 {
     // Act & Assert
     ImplicitExpressionTest(
         implicitExpresison,
         expectedImplicitExpression,
         acceptedCharacters,
         expectedErrors);
 }

        public void ToDiagnostic_ConvertsRazorErrorLocation_ToSourceLineMappings()
        {
            // Arrange
            var sourceLocation = new SourceLocation(absoluteIndex: 30, lineIndex: 10, characterIndex: 1);
            var error = new RazorError("some message", sourceLocation, length: 5);

            // Act
            var diagnostics = error.ToDiagnostics("/some-path");

            // Assert
            var span = diagnostics.Location.GetMappedLineSpan();
            Assert.Equal("/some-path", span.Path);
            Assert.Equal(10, span.StartLinePosition.Line);
            Assert.Equal(1, span.StartLinePosition.Character);
            Assert.Equal(10, span.EndLinePosition.Line);
            Assert.Equal(6, span.EndLinePosition.Character);
        }

        public void ToDiagnostic_SucceedsWhenRazorErrorLocationIsZeroOrUndefined(
            SourceLocation location,
            int length)
        {
            // Arrange
            var error = new RazorError("some message", location, length);

            // Act
            var diagnostics = error.ToDiagnostics("/some-path");

            // Assert
            var span = diagnostics.Location.GetMappedLineSpan();
            Assert.Equal("/some-path", span.Path);
            Assert.Equal(0, span.StartLinePosition.Line);
            Assert.Equal(0, span.StartLinePosition.Character);
            Assert.Equal(0, span.EndLinePosition.Line);
            Assert.Equal(0, span.EndLinePosition.Character);
        }

        public void RazorError_CanBeSerialized()
        {
            // Arrange
            var error = new RazorError(
                message: "Testing",
                location: new SourceLocation(absoluteIndex: 1, lineIndex: 2, characterIndex: 3),
                length: 456);
            var expectedSerializedError =
                $"{{\"{nameof(RazorError.Message)}\":\"Testing\",\"{nameof(RazorError.Location)}\":{{\"" +
                $"{nameof(SourceLocation.AbsoluteIndex)}\":1,\"{nameof(SourceLocation.LineIndex)}\":2,\"" +
                $"{nameof(SourceLocation.CharacterIndex)}\":3}},\"{nameof(RazorError.Length)}\":456}}";

            // Act
            var serializedError = JsonConvert.SerializeObject(error);

            // Assert
            Assert.Equal(expectedSerializedError, serializedError, StringComparer.Ordinal);
        }

        public void RazorError_CanBeDeserialized()
        {
            // Arrange
            var error = new RazorError(
                message: "Testing",
                location: new SourceLocation("somepath", absoluteIndex: 1, lineIndex: 2, characterIndex: 3),
                length: 456);
            var serializedError = JsonConvert.SerializeObject(error);

            // Act
            var deserializedError = JsonConvert.DeserializeObject<RazorError>(serializedError);

            // Assert
            Assert.Equal("Testing", deserializedError.Message, StringComparer.Ordinal);
            Assert.Equal(1, deserializedError.Location.AbsoluteIndex);
            Assert.Equal(2, deserializedError.Location.LineIndex);
            Assert.Equal(3, deserializedError.Location.CharacterIndex);
            Assert.Equal(456, deserializedError.Length);
        }

 public override void VisitError(RazorError err) {
     Visitor1.VisitError(err);
     Visitor2.VisitError(err);
 }

 public void ExceptionFilterErrors(
     string document,
     StatementBlock expectedStatement,
     RazorError[] expectedErrors)
 {
     // Act & Assert
     ParseBlockTest(document, expectedStatement, expectedErrors);
 }

        public void OnError(RazorError error)
        {
            EnusreNotTerminated();
            AssertOnOwnerTask();

            _errorSink.OnError(error);
        }

        public void Rewrite_CreatesErrorForWithoutEndTagTagStructureForEndTags()
        {
            // Arrange
            var factory = CreateDefaultSpanFactory();
            var blockFactory = new BlockFactory(factory);
            var expectedError = new RazorError(
                RazorResources.FormatTagHelperParseTreeRewriter_EndTagTagHelperMustNotHaveAnEndTag(
                    "input",
                    "InputTagHelper",
                    TagStructure.WithoutEndTag),
                absoluteIndex: 2,
                lineIndex: 0,
                columnIndex: 2,
                length: 5);
            var documentContent = "</input>";
            var expectedOutput = new MarkupBlock(blockFactory.MarkupTagBlock("</input>"));
            var descriptors = new TagHelperDescriptor[]
                {
                    new TagHelperDescriptor
                    {
                        TagName = "input",
                        TypeName = "InputTagHelper",
                        AssemblyName = "SomeAssembly",
                        TagStructure = TagStructure.WithoutEndTag
                    }
                };
            var descriptorProvider = new TagHelperDescriptorProvider(descriptors);

            // Act & Assert
            EvaluateData(descriptorProvider, documentContent, expectedOutput, expectedErrors: new[] { expectedError });
        }

        public void Rewrite_RequiredAttributeDescriptorsCreateMalformedTagHelperBlocksCorrectly(
            string documentContent,
            MarkupBlock expectedOutput,
            RazorError[] expectedErrors)
        {
            // Arrange
            var descriptors = new TagHelperDescriptor[]
                {
                    new TagHelperDescriptor(
                        tagName: "p",
                        typeName: "pTagHelper",
                        assemblyName: "SomeAssembly",
                        attributes: new TagHelperAttributeDescriptor[0],
                        requiredAttributes: new[] { "class" })
                };
            var descriptorProvider = new TagHelperDescriptorProvider(descriptors);

            // Act & Assert
            EvaluateData(descriptorProvider, documentContent, expectedOutput, expectedErrors);
        }

 /// <summary>
 /// Tracks the given <paramref name="error"/>.
 /// </summary>
 /// <param name="error">The <see cref="RazorError"/> to track.</param>
 public void OnError(RazorError error)
 {
     _errors.Add(error);
 }

 private static HttpParseException CreateExceptionFromParserError(RazorError error, string virtualPath)
 {
     return new HttpParseException(error.Message + Environment.NewLine, null, virtualPath, null, error.Location.LineIndex + 1);
 }

 private void NamespaceImportTest(string content, string expectedNS, AcceptedCharacters acceptedCharacters = AcceptedCharacters.None, string errorMessage = null, SourceLocation? location = null) {
     var errors = new RazorError[0];
     if (!String.IsNullOrEmpty(errorMessage) && location.HasValue) {
         errors = new RazorError[] { 
             new RazorError(errorMessage, location.Value) 
         };
     }
     ParseBlockTest(content,
                     new DirectiveBlock(
                         new NamespaceImportSpan(SpanKind.Code,
                                                 content,
                                                 acceptedCharacters,
                                                 expectedNS,
                                                 CSharpCodeParser.UsingKeywordLength)), errors);
 }

 public void Rewrite_AllowsTagHelperElementOptForIncompleteTextTagInCSharpBlock(
     string documentContent,
     MarkupBlock expectedOutput,
     RazorError[] expectedErrors)
 {
     RunParseTreeRewriterTest(documentContent, expectedOutput, expectedErrors, "text");
 }

 public virtual void VisitError(RazorError err)
 {
     ThrowIfCanceled();
 }

 /// <summary>
 /// Visits an error generated through parsing.
 /// </summary>
 /// <param name="err">The error that was generated.</param>
 public override void VisitError(RazorError err)
 {
     if (StrictMode)
         throw new TemplateParsingException(err);
 }

        public void Rewrite_UnderstandsMinimizedAttributes(
            string documentContent,
            MarkupBlock expectedOutput,
            RazorError[] expectedErrors)
        {
            // Arrange
            var descriptors = new TagHelperDescriptor[]
                {
                    new TagHelperDescriptor(
                        tagName: "input",
                        typeName: "InputTagHelper1",
                        assemblyName: "SomeAssembly",
                        attributes: new[]
                        {
                            new TagHelperAttributeDescriptor(
                                "bound-required-string",
                                "BoundRequiredString",
                                typeof(string).FullName,
                                isIndexer: false,
                                designTimeDescriptor: null)
                        },
                        requiredAttributes: new[] { "unbound-required" }),
                    new TagHelperDescriptor(
                        tagName: "input",
                        typeName: "InputTagHelper1",
                        assemblyName: "SomeAssembly",
                        attributes: new[]
                        {
                            new TagHelperAttributeDescriptor(
                                "bound-required-string",
                                "BoundRequiredString",
                                typeof(string).FullName,
                                isIndexer: false,
                                designTimeDescriptor: null)
                        },
                        requiredAttributes: new[] { "bound-required-string" }),
                    new TagHelperDescriptor(
                        tagName: "input",
                        typeName: "InputTagHelper2",
                        assemblyName: "SomeAssembly",
                        attributes: new[]
                        {
                            new TagHelperAttributeDescriptor(
                                "bound-required-int",
                                "BoundRequiredInt",
                                typeof(int).FullName,
                                isIndexer: false,
                                designTimeDescriptor: null)
                        },
                        requiredAttributes: new[] { "bound-required-int" }),
                    new TagHelperDescriptor(
                        tagName: "input",
                        typeName: "InputTagHelper3",
                        assemblyName: "SomeAssembly",
                        attributes: new[]
                        {
                            new TagHelperAttributeDescriptor(
                                "int-dictionary",
                                "DictionaryOfIntProperty",
                                typeof(IDictionary<string, int>).FullName,
                                isIndexer: false,
                                designTimeDescriptor: null),
                            new TagHelperAttributeDescriptor(
                                "string-dictionary",
                                "DictionaryOfStringProperty",
                                typeof(IDictionary<string, string>).FullName,
                                isIndexer: false,
                                designTimeDescriptor: null),
                            new TagHelperAttributeDescriptor(
                                "int-prefix-",
                                "DictionaryOfIntProperty",
                                typeof(int).FullName,
                                isIndexer: true,
                                designTimeDescriptor: null),
                            new TagHelperAttributeDescriptor(
                                "string-prefix-",
                                "DictionaryOfStringProperty",
                                typeof(string).FullName,
                                isIndexer: true,
                                designTimeDescriptor: null),
                        },
                        requiredAttributes: Enumerable.Empty<string>()),
                    new TagHelperDescriptor(
                        tagName: "p",
                        typeName: "PTagHelper",
                        assemblyName: "SomeAssembly",
                        attributes: new[]
                        {
                            new TagHelperAttributeDescriptor(
                                "bound-string",
                                "BoundRequiredString",
                                typeof(string).FullName,
                                isIndexer: false,
                                designTimeDescriptor: null),
                            new TagHelperAttributeDescriptor(
                                "bound-int",
                                "BoundRequiredString",
                                typeof(int).FullName,
                                isIndexer: false,
                                designTimeDescriptor: null)
//.........这里部分代码省略.........