Merge pull request #276 from Microsoft/dm/vnext/fix272

darrelmiller · web-flow · commit 9424e24ec5f6 · 2018-06-13T09:52:33.000-04:00
Fixes to syntax related reading errors
diff --git a/src/Microsoft.OpenApi.Readers/Exceptions/OpenApiReaderException.cs b/src/Microsoft.OpenApi.Readers/Exceptions/OpenApiReaderException.cs
@@ -2,14 +2,16 @@
 // Licensed under the MIT license. 
 
 using System;
+using Microsoft.OpenApi.Exceptions;
+using SharpYaml.Serialization;
 
 namespace Microsoft.OpenApi.Readers.Exceptions
 {
     /// <summary>
     /// Defines an exception indicating OpenAPI Reader encountered an issue while reading.
     /// </summary>
     [Serializable]
-    public class OpenApiReaderException : Exception
+    public class OpenApiReaderException : OpenApiException
     {
         /// <summary>
         /// Initializes the <see cref="OpenApiReaderException"/> class.
@@ -22,6 +24,18 @@ public OpenApiReaderException() { }
         /// <param name="message">Plain text error message for this exception.</param>
         public OpenApiReaderException(string message) : base(message) { }
 
+        /// <summary>
+        /// Initializes the <see cref="OpenApiReaderException"/> class with a message and line, column location of error.
+        /// </summary>
+        /// <param name="message">Plain text error message for this exception.</param>
+        /// <param name="node">Parsing node where error occured</param>
+        public OpenApiReaderException(string message, YamlNode node) : base(message)
+        {
+            // This only includes line because using a char range causes tests to break due to CR/LF & LF differences
+            // See https://tools.ietf.org/html/rfc5147 for syntax
+            Pointer = $"#line={node.Start.Line}";  
+        }
+
         /// <summary>
         /// Initializes the <see cref="OpenApiReaderException"/> class with a custom message and inner exception.
         /// </summary>
diff --git a/src/Microsoft.OpenApi.Readers/OpenApiReaderError.cs b/src/Microsoft.OpenApi.Readers/OpenApiReaderError.cs
diff --git a/src/Microsoft.OpenApi.Readers/OpenApiStreamReader.cs b/src/Microsoft.OpenApi.Readers/OpenApiStreamReader.cs
@@ -49,9 +49,9 @@ public OpenApiDocument Read(Stream input, out OpenApiDiagnostic diagnostic)
             {
                 yamlDocument = LoadYamlDocument(input);
             }
-            catch (SyntaxErrorException ex)
+            catch (YamlException ex)
             {
-                diagnostic.Errors.Add(new OpenApiReaderError(ex));
+                diagnostic.Errors.Add(new OpenApiError($"#char={ex.Start.Line}", ex.Message));
                 return new OpenApiDocument();
             }
 
@@ -122,9 +122,9 @@ public T ReadFragment<T>(Stream input, OpenApiSpecVersion version, out OpenApiDi
             {
                 yamlDocument = LoadYamlDocument(input);
             }
-            catch (SyntaxErrorException ex)
+            catch (YamlException ex)
             {
-                diagnostic.Errors.Add(new OpenApiReaderError(ex));
+                diagnostic.Errors.Add(new OpenApiError($"#line={ex.Start.Line}", ex.Message));
                 return default(T);
             }
 
@@ -158,7 +158,6 @@ public T ReadFragment<T>(Stream input, OpenApiSpecVersion version, out OpenApiDi
             return (T)element;
         }
 
-
         /// <summary>
         /// Helper method to turn streams into YamlDocument
         /// </summary>
diff --git a/src/Microsoft.OpenApi.Readers/ParseNodes/ListNode.cs b/src/Microsoft.OpenApi.Readers/ParseNodes/ListNode.cs
@@ -52,7 +52,7 @@ public override List<T> CreateSimpleList<T>(Func<ValueNode, T> map)
                     $"Expected list at line {_nodeList.Start.Line} while parsing {typeof(T).Name}");
             }
 
-            return _nodeList.Select(n => map(new ValueNode(Context, Diagnostic, (YamlScalarNode)n))).ToList();
+            return _nodeList.Select(n => map(new ValueNode(Context, Diagnostic, n))).ToList();
         }
 
         public IEnumerator<ParseNode> GetEnumerator()
diff --git a/src/Microsoft.OpenApi.Readers/ParseNodes/MapNode.cs b/src/Microsoft.OpenApi.Readers/ParseNodes/MapNode.cs
@@ -9,6 +9,7 @@
 using Microsoft.OpenApi.Exceptions;
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Readers.Exceptions;
 using SharpYaml.Schemas;
 using SharpYaml.Serialization;
 
@@ -27,16 +28,16 @@ public MapNode(ParsingContext context, OpenApiDiagnostic diagnostic, string yaml
         {
         }
 
-        public MapNode(ParsingContext context, OpenApiDiagnostic diagnostic, YamlMappingNode node) : base(
+        public MapNode(ParsingContext context, OpenApiDiagnostic diagnostic, YamlNode node) : base(
             context,
             diagnostic)
         {
-            if (node == null)
+            if (!(node is YamlMappingNode mapNode))
             {
-                throw new OpenApiException("Expected map");
+                throw new OpenApiReaderException("Expected map.", node);
             }
 
-            this._node = node;
+            this._node = mapNode;
 
             _nodes = this._node.Children
                 .Select(kvp => new PropertyNode(Context, Diagnostic, kvp.Key.GetScalarValue(), kvp.Value))
diff --git a/src/Microsoft.OpenApi.Readers/ParseNodes/ParseNode.cs b/src/Microsoft.OpenApi.Readers/ParseNodes/ParseNode.cs
@@ -8,6 +8,7 @@
 using Microsoft.OpenApi.Exceptions;
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Readers.Exceptions;
 using SharpYaml.Serialization;
 
 namespace Microsoft.OpenApi.Readers.ParseNodes
@@ -26,26 +27,23 @@ protected ParseNode(ParsingContext parsingContext, OpenApiDiagnostic diagnostic)
 
         public MapNode CheckMapNode(string nodeName)
         {
-            var mapNode = this as MapNode;
-            if (mapNode == null)
+            if (!(this is MapNode mapNode))
             {
-                throw new OpenApiException($"{nodeName} must be a map/object");
+                throw new OpenApiReaderException($"{nodeName} must be a map/object");
             }
 
             return mapNode;
         }
 
         public static ParseNode Create(ParsingContext context, OpenApiDiagnostic diagnostic, YamlNode node)
         {
-            var listNode = node as YamlSequenceNode;
 
-            if (listNode != null)
+            if (node is YamlSequenceNode listNode)
             {
                 return new ListNode(context, diagnostic, listNode);
             }
 
-            var mapNode = node as YamlMappingNode;
-            if (mapNode != null)
+            if (node is YamlMappingNode mapNode)
             {
                 return new MapNode(context, diagnostic, mapNode);
             }
@@ -55,50 +53,50 @@ public static ParseNode Create(ParsingContext context, OpenApiDiagnostic diagnos
 
         public virtual List<T> CreateList<T>(Func<MapNode, T> map)
         {
-            throw new OpenApiException("Cannot create list from this type of node.");
+            throw new OpenApiReaderException("Cannot create list from this type of node.");
         }
 
         public virtual Dictionary<string, T> CreateMap<T>(Func<MapNode, T> map)
         {
-            throw new OpenApiException("Cannot create map from this type of node.");
+            throw new OpenApiReaderException("Cannot create map from this type of node.");
         }
 
         public virtual Dictionary<string, T> CreateMapWithReference<T>(
             ReferenceType referenceType,
             Func<MapNode, T> map)
             where T : class, IOpenApiReferenceable
         {
-            throw new OpenApiException("Cannot create map from this reference.");
+            throw new OpenApiReaderException("Cannot create map from this reference.");
         }
 
         public virtual List<T> CreateSimpleList<T>(Func<ValueNode, T> map)
         {
-            throw new OpenApiException("Cannot create simple list from this type of node.");
+            throw new OpenApiReaderException("Cannot create simple list from this type of node.");
         }
 
         public virtual Dictionary<string, T> CreateSimpleMap<T>(Func<ValueNode, T> map)
         {
-            throw new OpenApiException("Cannot create simple map from this type of node.");
+            throw new OpenApiReaderException("Cannot create simple map from this type of node.");
         }
 
         public virtual IOpenApiAny CreateAny()
         {
-            throw new OpenApiException("Cannot create an Any object this type of node.");
+            throw new OpenApiReaderException("Cannot create an Any object this type of node.");
         }
 
         public virtual string GetRaw()
         {
-            throw new OpenApiException("Cannot get raw value from this type of node.");
+            throw new OpenApiReaderException("Cannot get raw value from this type of node.");
         }
 
         public virtual string GetScalarValue()
         {
-            throw new OpenApiException("Cannot create a scalar value from this type of node.");
+            throw new OpenApiReaderException("Cannot create a scalar value from this type of node.");
         }
 
         public virtual List<IOpenApiAny> CreateListOfAny()
         {
-            throw new OpenApiException("Cannot create a list from this type of node.");
+            throw new OpenApiReaderException("Cannot create a list from this type of node.");
         }
 
     }
diff --git a/src/Microsoft.OpenApi.Readers/ParseNodes/PropertyNode.cs b/src/Microsoft.OpenApi.Readers/ParseNodes/PropertyNode.cs
@@ -7,6 +7,7 @@
 using Microsoft.OpenApi.Any;
 using Microsoft.OpenApi.Exceptions;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Readers.Exceptions;
 using SharpYaml.Serialization;
 
 namespace Microsoft.OpenApi.Readers.ParseNodes
@@ -40,10 +41,14 @@ public void ParseField<T>(
                     Context.StartObject(Name);
                     fixedFieldMap(parentInstance, Value);
                 }
+                catch (OpenApiReaderException ex)
+                {
+                    Diagnostic.Errors.Add(new OpenApiError(ex));
+                }
                 catch (OpenApiException ex)
                 {
                     ex.Pointer = Context.GetLocation();
-                    Diagnostic.Errors.Add(new OpenApiReaderError(ex));
+                    Diagnostic.Errors.Add(new OpenApiError(ex));
                 }
                 finally
                 {
@@ -60,10 +65,14 @@ public void ParseField<T>(
                         Context.StartObject(Name);
                         map(parentInstance, Name, Value);
                     }
+                    catch (OpenApiReaderException ex)
+                    {
+                        Diagnostic.Errors.Add(new OpenApiError(ex));
+                    }
                     catch (OpenApiException ex)
                     {
                         ex.Pointer = Context.GetLocation();
-                        Diagnostic.Errors.Add(new OpenApiReaderError(ex));
+                        Diagnostic.Errors.Add(new OpenApiError(ex));
                     }
                     finally
                     {
diff --git a/src/Microsoft.OpenApi.Readers/ParseNodes/ValueNode.cs b/src/Microsoft.OpenApi.Readers/ParseNodes/ValueNode.cs
@@ -4,6 +4,7 @@
 using System;
 using Microsoft.OpenApi.Any;
 using Microsoft.OpenApi.Exceptions;
+using Microsoft.OpenApi.Readers.Exceptions;
 using SharpYaml.Serialization;
 
 namespace Microsoft.OpenApi.Readers.ParseNodes
@@ -12,23 +13,20 @@ internal class ValueNode : ParseNode
     {
         private readonly YamlScalarNode _node;
 
-        public ValueNode(ParsingContext context, OpenApiDiagnostic diagnostic, YamlScalarNode scalarNode) : base(
+        public ValueNode(ParsingContext context, OpenApiDiagnostic diagnostic, YamlNode node) : base(
             context,
             diagnostic)
         {
+            if (!(node is YamlScalarNode scalarNode))
+            {
+                throw new OpenApiReaderException("Expected a value.", node);
+            }
             _node = scalarNode;
         }
 
         public override string GetScalarValue()
         {
-            var scalarNode = _node;
-
-            if (scalarNode == null)
-            {
-                throw new OpenApiException($"Expected scalar at line {_node.Start.Line}");
-            }
-
-            return scalarNode.Value;
+            return _node.Value;
        }
 
         /// <summary>
diff --git a/src/Microsoft.OpenApi/Models/OpenApiError.cs b/src/Microsoft.OpenApi/Models/OpenApiError.cs
@@ -41,7 +41,7 @@ public OpenApiError(string pointer, string message)
         /// </summary>
         public override string ToString()
         {
-            return Message + (!string.IsNullOrEmpty(Pointer) ? " at " + Pointer : "");
+            return Message + (!string.IsNullOrEmpty(Pointer) ? " [" + Pointer + "]" : "" );
         }
     }
 }
diff --git a/test/Microsoft.OpenApi.Readers.Tests/ParseNodeTests.cs b/test/Microsoft.OpenApi.Readers.Tests/ParseNodeTests.cs
@@ -0,0 +1,35 @@
+﻿// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. 
+
+using System.Collections.Generic;
+using FluentAssertions;
+using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Readers;
+using Microsoft.OpenApi.Readers.Exceptions;
+using Xunit;
+
+namespace Microsoft.OpenApi.Tests
+{
+    public class ParseNodeTests
+    {
+        [Fact]
+        public void BrokenSimpleList()
+        {
+            var input = @"swagger: 2.0
+info:
+  title: hey
+  version: 1.0.0
+schemes: [ { ""hello"" }]
+paths: { }";
+
+            var reader = new OpenApiStringReader();
+            reader.Read(input, out var diagnostic);
+
+            diagnostic.Errors.ShouldBeEquivalentTo(new List<OpenApiError>() {
+                new OpenApiError(new OpenApiReaderException("Expected a value.") {
+                    Pointer = "#line=4"
+                })
+            });
+        }
+    }
+}
diff --git a/test/Microsoft.OpenApi.Readers.Tests/V2Tests/OpenApiDocumentTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V2Tests/OpenApiDocumentTests.cs
@@ -31,10 +31,11 @@ public void ShouldThrowWhenReferenceTypeIsInvalid()
 ";
 
             var reader = new OpenApiStringReader();
+            var doc = reader.Read(input, out var diagnostic);
 
-            Assert.Throws<OpenApiReaderException>(() => { 
-                var doc = reader.Read(input, out var diagnostic);
-            });
+            diagnostic.Errors.ShouldBeEquivalentTo(new List<OpenApiError> {
+                new OpenApiError( new OpenApiException("Unknown reference type 'defi888nition'")) });
+            doc.Should().NotBeNull();
         }
 
 

Original file line number	Diff line number	Diff line change
`@@ -49,9 +49,9 @@ public OpenApiDocument Read(Stream input, out OpenApiDiagnostic diagnostic)`
`49`	`49`	`{`
`50`	`50`	`yamlDocument = LoadYamlDocument(input);`
`51`	`51`	`}`
`52`		`- catch (SyntaxErrorException ex)`
	`52`	`+ catch (YamlException ex)`
`53`	`53`	`{`
`54`		`- diagnostic.Errors.Add(new OpenApiReaderError(ex));`
	`54`	`+ diagnostic.Errors.Add(new OpenApiError($"#char={ex.Start.Line}", ex.Message));`
`55`	`55`	`return new OpenApiDocument();`
`56`	`56`	`}`
`57`	`57`
`@@ -122,9 +122,9 @@ public T ReadFragment<T>(Stream input, OpenApiSpecVersion version, out OpenApiDi`
`122`	`122`	`{`
`123`	`123`	`yamlDocument = LoadYamlDocument(input);`
`124`	`124`	`}`
`125`		`- catch (SyntaxErrorException ex)`
	`125`	`+ catch (YamlException ex)`
`126`	`126`	`{`
`127`		`- diagnostic.Errors.Add(new OpenApiReaderError(ex));`
	`127`	`+ diagnostic.Errors.Add(new OpenApiError($"#line={ex.Start.Line}", ex.Message));`
`128`	`128`	`return default(T);`
`129`	`129`	`}`
`130`	`130`
`@@ -158,7 +158,6 @@ public T ReadFragment<T>(Stream input, OpenApiSpecVersion version, out OpenApiDi`
`158`	`158`	`return (T)element;`
`159`	`159`	`}`
`160`	`160`
`161`		`-`
`162`	`161`	`/// <summary>`
`163`	`162`	`/// Helper method to turn streams into YamlDocument`
`164`	`163`	`/// </summary>`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public override List<T> CreateSimpleList<T>(Func<ValueNode, T> map)`
`52`	`52`	`$"Expected list at line {_nodeList.Start.Line} while parsing {typeof(T).Name}");`
`53`	`53`	`}`
`54`	`54`
`55`		`- return _nodeList.Select(n => map(new ValueNode(Context, Diagnostic, (YamlScalarNode)n))).ToList();`
	`55`	`+ return _nodeList.Select(n => map(new ValueNode(Context, Diagnostic, n))).ToList();`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`public IEnumerator<ParseNode> GetEnumerator()`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`using Microsoft.OpenApi.Exceptions;`
`10`	`10`	`using Microsoft.OpenApi.Interfaces;`
`11`	`11`	`using Microsoft.OpenApi.Models;`
	`12`	`+using Microsoft.OpenApi.Readers.Exceptions;`
`12`	`13`	`using SharpYaml.Schemas;`
`13`	`14`	`using SharpYaml.Serialization;`
`14`	`15`
`@@ -27,16 +28,16 @@ public MapNode(ParsingContext context, OpenApiDiagnostic diagnostic, string yaml`
`27`	`28`	`{`
`28`	`29`	`}`
`29`	`30`
`30`		`- public MapNode(ParsingContext context, OpenApiDiagnostic diagnostic, YamlMappingNode node) : base(`
	`31`	`+ public MapNode(ParsingContext context, OpenApiDiagnostic diagnostic, YamlNode node) : base(`
`31`	`32`	`context,`
`32`	`33`	`diagnostic)`
`33`	`34`	`{`
`34`		`- if (node == null)`
	`35`	`+ if (!(node is YamlMappingNode mapNode))`
`35`	`36`	`{`
`36`		`- throw new OpenApiException("Expected map");`
	`37`	`+ throw new OpenApiReaderException("Expected map.", node);`
`37`	`38`	`}`
`38`	`39`
`39`		`- this._node = node;`
	`40`	`+ this._node = mapNode;`
`40`	`41`
`41`	`42`	`_nodes = this._node.Children`
`42`	`43`	`.Select(kvp => new PropertyNode(Context, Diagnostic, kvp.Key.GetScalarValue(), kvp.Value))`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`using Microsoft.OpenApi.Exceptions;`
`9`	`9`	`using Microsoft.OpenApi.Interfaces;`
`10`	`10`	`using Microsoft.OpenApi.Models;`
	`11`	`+using Microsoft.OpenApi.Readers.Exceptions;`
`11`	`12`	`using SharpYaml.Serialization;`
`12`	`13`
`13`	`14`	`namespace Microsoft.OpenApi.Readers.ParseNodes`
`@@ -26,26 +27,23 @@ protected ParseNode(ParsingContext parsingContext, OpenApiDiagnostic diagnostic)`
`26`	`27`
`27`	`28`	`public MapNode CheckMapNode(string nodeName)`
`28`	`29`	`{`
`29`		`- var mapNode = this as MapNode;`
`30`		`- if (mapNode == null)`
	`30`	`+ if (!(this is MapNode mapNode))`
`31`	`31`	`{`
`32`		`- throw new OpenApiException($"{nodeName} must be a map/object");`
	`32`	`+ throw new OpenApiReaderException($"{nodeName} must be a map/object");`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`return mapNode;`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`public static ParseNode Create(ParsingContext context, OpenApiDiagnostic diagnostic, YamlNode node)`
`39`	`39`	`{`
`40`		`- var listNode = node as YamlSequenceNode;`
`41`	`40`
`42`		`- if (listNode != null)`
	`41`	`+ if (node is YamlSequenceNode listNode)`
`43`	`42`	`{`
`44`	`43`	`return new ListNode(context, diagnostic, listNode);`
`45`	`44`	`}`
`46`	`45`
`47`		`- var mapNode = node as YamlMappingNode;`
`48`		`- if (mapNode != null)`
	`46`	`+ if (node is YamlMappingNode mapNode)`
`49`	`47`	`{`
`50`	`48`	`return new MapNode(context, diagnostic, mapNode);`
`51`	`49`	`}`
`@@ -55,50 +53,50 @@ public static ParseNode Create(ParsingContext context, OpenApiDiagnostic diagnos`
`55`	`53`
`56`	`54`	`public virtual List<T> CreateList<T>(Func<MapNode, T> map)`
`57`	`55`	`{`
`58`		`- throw new OpenApiException("Cannot create list from this type of node.");`
	`56`	`+ throw new OpenApiReaderException("Cannot create list from this type of node.");`
`59`	`57`	`}`
`60`	`58`
`61`	`59`	`public virtual Dictionary<string, T> CreateMap<T>(Func<MapNode, T> map)`
`62`	`60`	`{`
`63`		`- throw new OpenApiException("Cannot create map from this type of node.");`
	`61`	`+ throw new OpenApiReaderException("Cannot create map from this type of node.");`
`64`	`62`	`}`
`65`	`63`
`66`	`64`	`public virtual Dictionary<string, T> CreateMapWithReference<T>(`
`67`	`65`	`ReferenceType referenceType,`
`68`	`66`	`Func<MapNode, T> map)`
`69`	`67`	`where T : class, IOpenApiReferenceable`
`70`	`68`	`{`
`71`		`- throw new OpenApiException("Cannot create map from this reference.");`
	`69`	`+ throw new OpenApiReaderException("Cannot create map from this reference.");`
`72`	`70`	`}`
`73`	`71`
`74`	`72`	`public virtual List<T> CreateSimpleList<T>(Func<ValueNode, T> map)`
`75`	`73`	`{`
`76`		`- throw new OpenApiException("Cannot create simple list from this type of node.");`
	`74`	`+ throw new OpenApiReaderException("Cannot create simple list from this type of node.");`
`77`	`75`	`}`
`78`	`76`
`79`	`77`	`public virtual Dictionary<string, T> CreateSimpleMap<T>(Func<ValueNode, T> map)`
`80`	`78`	`{`
`81`		`- throw new OpenApiException("Cannot create simple map from this type of node.");`
	`79`	`+ throw new OpenApiReaderException("Cannot create simple map from this type of node.");`
`82`	`80`	`}`
`83`	`81`
`84`	`82`	`public virtual IOpenApiAny CreateAny()`
`85`	`83`	`{`
`86`		`- throw new OpenApiException("Cannot create an Any object this type of node.");`
	`84`	`+ throw new OpenApiReaderException("Cannot create an Any object this type of node.");`
`87`	`85`	`}`
`88`	`86`
`89`	`87`	`public virtual string GetRaw()`
`90`	`88`	`{`
`91`		`- throw new OpenApiException("Cannot get raw value from this type of node.");`
	`89`	`+ throw new OpenApiReaderException("Cannot get raw value from this type of node.");`
`92`	`90`	`}`
`93`	`91`
`94`	`92`	`public virtual string GetScalarValue()`
`95`	`93`	`{`
`96`		`- throw new OpenApiException("Cannot create a scalar value from this type of node.");`
	`94`	`+ throw new OpenApiReaderException("Cannot create a scalar value from this type of node.");`
`97`	`95`	`}`
`98`	`96`
`99`	`97`	`public virtual List<IOpenApiAny> CreateListOfAny()`
`100`	`98`	`{`
`101`		`- throw new OpenApiException("Cannot create a list from this type of node.");`
	`99`	`+ throw new OpenApiReaderException("Cannot create a list from this type of node.");`
`102`	`100`	`}`
`103`	`101`
`104`	`102`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`	`using Microsoft.OpenApi.Any;`
`8`	`8`	`using Microsoft.OpenApi.Exceptions;`
`9`	`9`	`using Microsoft.OpenApi.Models;`
	`10`	`+using Microsoft.OpenApi.Readers.Exceptions;`
`10`	`11`	`using SharpYaml.Serialization;`
`11`	`12`
`12`	`13`	`namespace Microsoft.OpenApi.Readers.ParseNodes`
`@@ -40,10 +41,14 @@ public void ParseField<T>(`
`40`	`41`	`Context.StartObject(Name);`
`41`	`42`	`fixedFieldMap(parentInstance, Value);`
`42`	`43`	`}`
	`44`	`+ catch (OpenApiReaderException ex)`
	`45`	`+ {`
	`46`	`+ Diagnostic.Errors.Add(new OpenApiError(ex));`
	`47`	`+ }`
`43`	`48`	`catch (OpenApiException ex)`
`44`	`49`	`{`
`45`	`50`	`ex.Pointer = Context.GetLocation();`
`46`		`- Diagnostic.Errors.Add(new OpenApiReaderError(ex));`
	`51`	`+ Diagnostic.Errors.Add(new OpenApiError(ex));`
`47`	`52`	`}`
`48`	`53`	`finally`
`49`	`54`	`{`
`@@ -60,10 +65,14 @@ public void ParseField<T>(`
`60`	`65`	`Context.StartObject(Name);`
`61`	`66`	`map(parentInstance, Name, Value);`
`62`	`67`	`}`
	`68`	`+ catch (OpenApiReaderException ex)`
	`69`	`+ {`
	`70`	`+ Diagnostic.Errors.Add(new OpenApiError(ex));`
	`71`	`+ }`
`63`	`72`	`catch (OpenApiException ex)`
`64`	`73`	`{`
`65`	`74`	`ex.Pointer = Context.GetLocation();`
`66`		`- Diagnostic.Errors.Add(new OpenApiReaderError(ex));`
	`75`	`+ Diagnostic.Errors.Add(new OpenApiError(ex));`
`67`	`76`	`}`
`68`	`77`	`finally`
`69`	`78`	`{`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ public OpenApiError(string pointer, string message)`
`41`	`41`	`/// </summary>`
`42`	`42`	`public override string ToString()`
`43`	`43`	`{`
`44`		`- return Message + (!string.IsNullOrEmpty(Pointer) ? " at " + Pointer : "");`
	`44`	`+ return Message + (!string.IsNullOrEmpty(Pointer) ? " [" + Pointer + "]" : "" );`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`	`}`