Fix NRT warnings in Word converter

jskeet · jskeet · commit d901dfbe49d4 · 2023-11-27T15:38:06.000Z
Many of these are fixed with just pattern matching. I've been liberal with the null-forgiving operator in the Word document code itself, but most of the rest is fairly straightforward to handle safely. Fixes #998.
diff --git a/tools/MarkdownConverter.Tests/MarkdownSpecFileListTests.cs b/tools/MarkdownConverter.Tests/MarkdownSpecFileListTests.cs
@@ -1,4 +1,4 @@
-using MarkdownConverter.Spec;
+﻿using MarkdownConverter.Spec;
 using Xunit;
 
 namespace MarkdownConverter.Tests;
@@ -8,6 +8,6 @@ public class MarkdownSpecFileListTests
     [Fact]
     public void EmptyListTest()
     {
-        Assert.Throws<ArgumentNullException>(() => MarkdownSpec.ReadFiles(null, new Reporter(TextWriter.Null)));
+        Assert.Throws<ArgumentNullException>(() => MarkdownSpec.ReadFiles(null!, new Reporter(TextWriter.Null)));
     }
-}
+}
diff --git a/tools/MarkdownConverter/Converter/MarkdownSourceConverter.cs b/tools/MarkdownConverter/Converter/MarkdownSourceConverter.cs
diff --git a/tools/MarkdownConverter/Converter/MarkdownSpecConverter.cs b/tools/MarkdownConverter/Converter/MarkdownSpecConverter.cs
@@ -17,12 +17,12 @@ public static void ConvertToWord(MarkdownSpec spec, string templateFile, string
                 resultDoc.AddPart(part.OpenXmlPart, part.RelationshipId);
             }
 
-            var body = resultDoc.MainDocumentPart.Document.Body;
+            var body = resultDoc.MainDocumentPart!.Document.Body!;
 
             ReplaceTableOfContents(spec, body);
 
             var context = new ConversionContext();
-            context.MaxBookmarkId.Value = 1 + body.Descendants<BookmarkStart>().Max(bookmark => int.Parse(bookmark.Id));
+            context.MaxBookmarkId.Value = 1 + body.Descendants<BookmarkStart>().Max(bookmark => int.Parse(bookmark.Id!));
 
             foreach (var src in spec.Sources)
             {
@@ -72,9 +72,12 @@ private static void ReplaceTableOfContents(MarkdownSpec spec, Body body)
         }
     }
 
-    private static bool FindToc(Body body, out int ifirst, out int iLast, out string instr, out Paragraph secBreak)
+    private static bool FindToc(Body body, out int ifirst, out int iLast, out string? instr, out Paragraph? secBreak)
     {
-        ifirst = -1; iLast = -1; instr = null; secBreak = null;
+        ifirst = -1;
+        iLast = -1;
+        instr = null;
+        secBreak = null;
 
         for (int i = 0; i < body.ChildElements.Count; i++)
         {
@@ -86,23 +89,25 @@ private static bool FindToc(Body body, out int ifirst, out int iLast, out string
 
             // The TOC might be a simple field
             var sf = p.OfType<SimpleField>().FirstOrDefault();
-            if (sf != null && sf.Instruction.Value.Contains("TOC"))
+            if (sf?.Instruction?.Value?.Contains("TOC") == true)
             {
                 if (ifirst != -1)
                 {
                     throw new Exception("Found start of TOC and then another simple TOC");
                 }
 
-                ifirst = i; iLast = i; instr = sf.Instruction.Value;
+                ifirst = i;
+                iLast = i;
+                instr = sf.Instruction.Value;
                 break;
             }
 
             // or it might be a complex field
             var runElements = (from r in p.OfType<Run>() from e in r select e).ToList();
-            var f1 = runElements.FindIndex(f => f is FieldChar && (f as FieldChar).FieldCharType.Value == FieldCharValues.Begin);
-            var f2 = runElements.FindIndex(f => f is FieldCode && (f as FieldCode).Text.Contains("TOC"));
-            var f3 = runElements.FindIndex(f => f is FieldChar && (f as FieldChar).FieldCharType.Value == FieldCharValues.Separate);
-            var f4 = runElements.FindIndex(f => f is FieldChar && (f as FieldChar).FieldCharType.Value == FieldCharValues.End);
+            var f1 = runElements.FindIndex(f => f is FieldChar fc && fc.FieldCharType?.Value == FieldCharValues.Begin);
+            var f2 = runElements.FindIndex(f => f is FieldCode fc && fc.Text.Contains("TOC"));
+            var f3 = runElements.FindIndex(f => f is FieldChar fc && fc.FieldCharType?.Value == FieldCharValues.Separate);
+            var f4 = runElements.FindIndex(f => f is FieldChar fc && fc.FieldCharType?.Value == FieldCharValues.End);
 
             if (f1 != -1 && f2 != -1 && f3 != -1 && f2 > f1 && f3 > f2)
             {
@@ -111,7 +116,8 @@ private static bool FindToc(Body body, out int ifirst, out int iLast, out string
                     throw new Exception("Found start of TOC and then another start of TOC");
                 }
 
-                ifirst = i; instr = (runElements[f2] as FieldCode).Text;
+                ifirst = i;
+                instr = ((FieldCode) runElements[f2]).Text;
             }
             if (f4 != -1 && f4 > f1 && f4 > f2 && f4 > f3)
             {
@@ -141,7 +147,7 @@ private static bool FindToc(Body body, out int ifirst, out int iLast, out string
                 continue;
             }
 
-            var sp = p.ParagraphProperties.OfType<SectionProperties>().FirstOrDefault();
+            var sp = p.ParagraphProperties?.OfType<SectionProperties>().FirstOrDefault();
             if (sp == null)
             {
                 continue;
diff --git a/tools/MarkdownConverter/OptionExtensions.cs b/tools/MarkdownConverter/OptionExtensions.cs
@@ -4,7 +4,7 @@ namespace MarkdownConverter;
 
 internal static class OptionExtensions
 {
-    public static T Option<T>(this FSharpOption<T> o) where T : class
+    public static T? Option<T>(this FSharpOption<T> o) where T : class
     {
         if (FSharpOption<T>.GetTag(o) == FSharpOption<T>.Tags.None)
         {
diff --git a/tools/MarkdownConverter/Program.cs b/tools/MarkdownConverter/Program.cs
@@ -36,7 +36,8 @@ static int Main(string[] args)
             else
             {
                 // Windows command-shell doesn't do globbing, so we have to do it ourselves
-                string dir = Path.GetDirectoryName(arg), filename = Path.GetFileName(arg);
+                string dir = Path.GetDirectoryName(arg) ?? throw new ArgumentException($"'{arg}' is a root directory");
+                string filename = Path.GetFileName(arg);
                 if (dir.Contains("*") || dir.Contains("?"))
                 {
                     Console.Error.WriteLine("Can't match wildcard directory names");
@@ -55,7 +56,8 @@ static int Main(string[] args)
         }
 
         var imdfiles = new List<string>();
-        string idocxfile = null, odocfile = null;
+        string? idocxfile = null;
+        string? odocfile = null;
         foreach (var ifile in ifiles)
         {
             var name = Path.GetFileName(ifile);
@@ -126,7 +128,7 @@ static int Main(string[] args)
             Console.WriteLine($"Writing '{Path.GetFileName(odocfile2)}'");
             try
             {
-                MarkdownSpecConverter.ConvertToWord(md, idocxfile, odocfile2, reporter);
+                MarkdownSpecConverter.ConvertToWord(md, idocxfile!, odocfile2, reporter);
             }
             catch (Exception ex)
             {
@@ -142,4 +144,4 @@ static int Main(string[] args)
         Console.WriteLine($"Warnings: {reporter.Warnings}");
         return reporter.Errors == 0 ? 0 : 1;
     }
-}
+}
diff --git a/tools/MarkdownConverter/Spec/MarkdownSpec.cs b/tools/MarkdownConverter/Spec/MarkdownSpec.cs
@@ -55,9 +55,12 @@ private MarkdownSpec(IEnumerable<Tuple<string, MarkdownDocument>> sources, Repor
         }
     }
 
-    public static MarkdownSpec ReadFiles(IEnumerable<string> files, Reporter reporter, Func<string, TextReader> readerProvider = null)
+    public static MarkdownSpec ReadFiles(IEnumerable<string> files, Reporter reporter, Func<string, TextReader>? readerProvider = null)
     {
-        if (files is null) throw new ArgumentNullException(nameof(files));
+        if (files is null)
+        {
+            throw new ArgumentNullException(nameof(files));
+        }
 
         readerProvider ??= File.OpenText;
 
diff --git a/tools/MarkdownConverter/Spec/Reporter.cs b/tools/MarkdownConverter/Spec/Reporter.cs
@@ -18,14 +18,14 @@ public class Reporter
     /// <summary>
     /// The parent reporter, if any. (This is to allow a complete error/warning count to be kept.)
     /// </summary>
-    private readonly Reporter parent;
+    private readonly Reporter? parent;
 
     public int Errors { get; private set; }
     public int Warnings { get; private set; }
 
     public SourceLocation Location { get; set; } = new SourceLocation(null, null, null, null);
 
-    private Reporter(Reporter parent, TextWriter writer, string filename)
+    private Reporter(Reporter? parent, TextWriter writer, string? filename)
     {
         this.parent = parent;
         this.writer = writer;
@@ -38,33 +38,33 @@ public Reporter(TextWriter writer) : this(null, writer, null)
 
     public Reporter WithFileName(string filename) => new Reporter(this, writer, filename);
 
-    public string CurrentFile => Location.File;
+    public string? CurrentFile => Location.File;
 
-    public SectionRef CurrentSection
+    public SectionRef? CurrentSection
     {
         get => Location.Section;
         set => Location = new SourceLocation(CurrentFile, value, CurrentParagraph, null);
     }
 
-    public MarkdownParagraph CurrentParagraph
+    public MarkdownParagraph? CurrentParagraph
     {
         get => Location.Paragraph;
         set => Location = new SourceLocation(CurrentFile, CurrentSection, value, null);
     }
 
-    public MarkdownSpan CurrentSpan
+    public MarkdownSpan? CurrentSpan
     {
         get => Location.Span;
         set => Location = new SourceLocation(CurrentFile, CurrentSection, CurrentParagraph, value);
     }
 
-    public void Error(string code, string msg, SourceLocation loc = null)
+    public void Error(string code, string msg, SourceLocation? loc = null)
     {
         IncrementErrors();
         Report(code, "ERROR", msg, loc?.Description ?? Location.Description);
     }
 
-    public void Warning(string code, string msg, SourceLocation loc = null)
+    public void Warning(string code, string msg, SourceLocation? loc = null)
     {
         IncrementWarnings();
         Report(code, "WARNING", msg, loc?.Description ?? Location.Description);
diff --git a/tools/MarkdownConverter/Spec/SectionRef.cs b/tools/MarkdownConverter/Spec/SectionRef.cs
@@ -7,7 +7,7 @@ public class SectionRef
     /// <summary>
     /// Section number, e.g. 10.1.2, or A.3 or null for sections without a number (e.g. Foreword).
     /// </summary>
-    public string Number { get;  }
+    public string? Number { get;  }
 
     /// <summary>
     /// Section title, e.g. "10.1.2 Goto Statement"
@@ -43,9 +43,9 @@ public SectionRef(MarkdownParagraph.Heading mdh, string filename, string bookmar
     {
         Level = mdh.size;
         var spans = mdh.body;
-        if (spans.Length == 1 && spans.First().IsLiteral)
+        if (spans.Length == 1 && spans.First() is MarkdownSpan.Literal literal)
         {
-            Title = MarkdownUtilities.UnescapeLiteral(spans.First() as MarkdownSpan.Literal).Trim();
+            Title = MarkdownUtilities.UnescapeLiteral(literal).Trim();
             if (char.IsDigit(Title[0]) || (Title[0] >= 'A' && Title[0] <= 'D' && Title[1] == '.'))
             {
                 var titleParts = Title.Split(new[] { ' ' }, 2);
diff --git a/tools/MarkdownConverter/Spec/SourceLocation.cs b/tools/MarkdownConverter/Spec/SourceLocation.cs
@@ -6,13 +6,13 @@ namespace MarkdownConverter.Spec;
 
 public class SourceLocation
 {
-    public string File { get; }
-    public SectionRef Section { get; }
-    public MarkdownParagraph Paragraph { get; }
-    public MarkdownSpan Span { get; }
-    public string _loc; // generated lazily.
+    public string? File { get; }
+    public SectionRef? Section { get; }
+    public MarkdownParagraph? Paragraph { get; }
+    public MarkdownSpan? Span { get; }
+    public string? _loc; // generated lazily.
 
-    public SourceLocation(string file, SectionRef section, MarkdownParagraph paragraph, MarkdownSpan span)
+    public SourceLocation(string? file, SectionRef? section, MarkdownParagraph? paragraph, MarkdownSpan? span)
     {
         File = file;
         Section = section;
@@ -42,19 +42,21 @@ public string Description
             }
             else
             {
+                // TODO: Revisit all of the null-forgiving operator usage here at some point.
+
                 // Note: we now use the F# Markdown support for ranges, rather than finding text directly.
                 // This produces slightly weaker diagnostics than before, but it avoids an awful lot of fiddly fuzzy text matching code.
                 
                 // TODO: Revisit SectionRef.Loc, possibly just exposing the paragraph directly.
-                var maybeRange = GetRange(Span);
+                var maybeRange = GetRange(Span!);
                 if (maybeRange != null)
                 {
                     var range = maybeRange.Value;
                     _loc = $"{File}({range.StartLine},{range.StartColumn},{range.EndLine},{range.EndColumn})";
                 }
                 else
                 {
-                    maybeRange = GetRange(Paragraph) ?? GetRange(Section.Loc.Paragraph);
+                    maybeRange = GetRange(Paragraph!) ?? GetRange(Section!.Loc.Paragraph!);
                     if (maybeRange == null)
                     {
                         // We don't have any line or column information. Just report the filename.
diff --git a/tools/MarkdownConverter/Spec/StringLengthComparer.cs b/tools/MarkdownConverter/Spec/StringLengthComparer.cs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-using MarkdownConverter.Spec;`
	`1`	`+using MarkdownConverter.Spec;`
`2`	`2`	`using Xunit;`
`3`	`3`
`4`	`4`	`namespace MarkdownConverter.Tests;`
`@@ -8,6 +8,6 @@ public class MarkdownSpecFileListTests`
`8`	`8`	`[Fact]`
`9`	`9`	`public void EmptyListTest()`
`10`	`10`	`{`
`11`		`- Assert.Throws<ArgumentNullException>(() => MarkdownSpec.ReadFiles(null, new Reporter(TextWriter.Null)));`
	`11`	`+ Assert.Throws<ArgumentNullException>(() => MarkdownSpec.ReadFiles(null!, new Reporter(TextWriter.Null)));`
`12`	`12`	`}`
`13`		`-}`
	`13`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -17,12 +17,12 @@ public static void ConvertToWord(MarkdownSpec spec, string templateFile, string`
`17`	`17`	`resultDoc.AddPart(part.OpenXmlPart, part.RelationshipId);`
`18`	`18`	`}`
`19`	`19`
`20`		`- var body = resultDoc.MainDocumentPart.Document.Body;`
	`20`	`+ var body = resultDoc.MainDocumentPart!.Document.Body!;`
`21`	`21`
`22`	`22`	`ReplaceTableOfContents(spec, body);`
`23`	`23`
`24`	`24`	`var context = new ConversionContext();`
`25`		`- context.MaxBookmarkId.Value = 1 + body.Descendants<BookmarkStart>().Max(bookmark => int.Parse(bookmark.Id));`
	`25`	`+ context.MaxBookmarkId.Value = 1 + body.Descendants<BookmarkStart>().Max(bookmark => int.Parse(bookmark.Id!));`
`26`	`26`
`27`	`27`	`foreach (var src in spec.Sources)`
`28`	`28`	`{`
`@@ -72,9 +72,12 @@ private static void ReplaceTableOfContents(MarkdownSpec spec, Body body)`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`
`75`		`- private static bool FindToc(Body body, out int ifirst, out int iLast, out string instr, out Paragraph secBreak)`
	`75`	`+ private static bool FindToc(Body body, out int ifirst, out int iLast, out string? instr, out Paragraph? secBreak)`
`76`	`76`	`{`
`77`		`- ifirst = -1; iLast = -1; instr = null; secBreak = null;`
	`77`	`+ ifirst = -1;`
	`78`	`+ iLast = -1;`
	`79`	`+ instr = null;`
	`80`	`+ secBreak = null;`
`78`	`81`
`79`	`82`	`for (int i = 0; i < body.ChildElements.Count; i++)`
`80`	`83`	`{`
`@@ -86,23 +89,25 @@ private static bool FindToc(Body body, out int ifirst, out int iLast, out string`
`86`	`89`
`87`	`90`	`// The TOC might be a simple field`
`88`	`91`	`var sf = p.OfType<SimpleField>().FirstOrDefault();`
`89`		`- if (sf != null && sf.Instruction.Value.Contains("TOC"))`
	`92`	`+ if (sf?.Instruction?.Value?.Contains("TOC") == true)`
`90`	`93`	`{`
`91`	`94`	`if (ifirst != -1)`
`92`	`95`	`{`
`93`	`96`	`throw new Exception("Found start of TOC and then another simple TOC");`
`94`	`97`	`}`
`95`	`98`
`96`		`- ifirst = i; iLast = i; instr = sf.Instruction.Value;`
	`99`	`+ ifirst = i;`
	`100`	`+ iLast = i;`
	`101`	`+ instr = sf.Instruction.Value;`
`97`	`102`	`break;`
`98`	`103`	`}`
`99`	`104`
`100`	`105`	`// or it might be a complex field`
`101`	`106`	`var runElements = (from r in p.OfType<Run>() from e in r select e).ToList();`
`102`		`- var f1 = runElements.FindIndex(f => f is FieldChar && (f as FieldChar).FieldCharType.Value == FieldCharValues.Begin);`
`103`		`- var f2 = runElements.FindIndex(f => f is FieldCode && (f as FieldCode).Text.Contains("TOC"));`
`104`		`- var f3 = runElements.FindIndex(f => f is FieldChar && (f as FieldChar).FieldCharType.Value == FieldCharValues.Separate);`
`105`		`- var f4 = runElements.FindIndex(f => f is FieldChar && (f as FieldChar).FieldCharType.Value == FieldCharValues.End);`
	`107`	`+ var f1 = runElements.FindIndex(f => f is FieldChar fc && fc.FieldCharType?.Value == FieldCharValues.Begin);`
	`108`	`+ var f2 = runElements.FindIndex(f => f is FieldCode fc && fc.Text.Contains("TOC"));`
	`109`	`+ var f3 = runElements.FindIndex(f => f is FieldChar fc && fc.FieldCharType?.Value == FieldCharValues.Separate);`
	`110`	`+ var f4 = runElements.FindIndex(f => f is FieldChar fc && fc.FieldCharType?.Value == FieldCharValues.End);`
`106`	`111`
`107`	`112`	`if (f1 != -1 && f2 != -1 && f3 != -1 && f2 > f1 && f3 > f2)`
`108`	`113`	`{`
`@@ -111,7 +116,8 @@ private static bool FindToc(Body body, out int ifirst, out int iLast, out string`
`111`	`116`	`throw new Exception("Found start of TOC and then another start of TOC");`
`112`	`117`	`}`
`113`	`118`
`114`		`- ifirst = i; instr = (runElements[f2] as FieldCode).Text;`
	`119`	`+ ifirst = i;`
	`120`	`+ instr = ((FieldCode) runElements[f2]).Text;`
`115`	`121`	`}`
`116`	`122`	`if (f4 != -1 && f4 > f1 && f4 > f2 && f4 > f3)`
`117`	`123`	`{`
`@@ -141,7 +147,7 @@ private static bool FindToc(Body body, out int ifirst, out int iLast, out string`
`141`	`147`	`continue;`
`142`	`148`	`}`
`143`	`149`
`144`		`- var sp = p.ParagraphProperties.OfType<SectionProperties>().FirstOrDefault();`
	`150`	`+ var sp = p.ParagraphProperties?.OfType<SectionProperties>().FirstOrDefault();`
`145`	`151`	`if (sp == null)`
`146`	`152`	`{`
`147`	`153`	`continue;`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ namespace MarkdownConverter;`
`4`	`4`
`5`	`5`	`internal static class OptionExtensions`
`6`	`6`	`{`
`7`		`- public static T Option<T>(this FSharpOption<T> o) where T : class`
	`7`	`+ public static T? Option<T>(this FSharpOption<T> o) where T : class`
`8`	`8`	`{`
`9`	`9`	`if (FSharpOption<T>.GetTag(o) == FSharpOption<T>.Tags.None)`
`10`	`10`	`{`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,8 @@ static int Main(string[] args)`
`36`	`36`	`else`
`37`	`37`	`{`
`38`	`38`	`// Windows command-shell doesn't do globbing, so we have to do it ourselves`
`39`		`- string dir = Path.GetDirectoryName(arg), filename = Path.GetFileName(arg);`
	`39`	`+ string dir = Path.GetDirectoryName(arg) ?? throw new ArgumentException($"'{arg}' is a root directory");`
	`40`	`+ string filename = Path.GetFileName(arg);`
`40`	`41`	`if (dir.Contains("*") \|\| dir.Contains("?"))`
`41`	`42`	`{`
`42`	`43`	`Console.Error.WriteLine("Can't match wildcard directory names");`
`@@ -55,7 +56,8 @@ static int Main(string[] args)`
`55`	`56`	`}`
`56`	`57`
`57`	`58`	`var imdfiles = new List<string>();`
`58`		`- string idocxfile = null, odocfile = null;`
	`59`	`+ string? idocxfile = null;`
	`60`	`+ string? odocfile = null;`
`59`	`61`	`foreach (var ifile in ifiles)`
`60`	`62`	`{`
`61`	`63`	`var name = Path.GetFileName(ifile);`
`@@ -126,7 +128,7 @@ static int Main(string[] args)`
`126`	`128`	`Console.WriteLine($"Writing '{Path.GetFileName(odocfile2)}'");`
`127`	`129`	`try`
`128`	`130`	`{`
`129`		`- MarkdownSpecConverter.ConvertToWord(md, idocxfile, odocfile2, reporter);`
	`131`	`+ MarkdownSpecConverter.ConvertToWord(md, idocxfile!, odocfile2, reporter);`
`130`	`132`	`}`
`131`	`133`	`catch (Exception ex)`
`132`	`134`	`{`
`@@ -142,4 +144,4 @@ static int Main(string[] args)`
`142`	`144`	`Console.WriteLine($"Warnings: {reporter.Warnings}");`
`143`	`145`	`return reporter.Errors == 0 ? 0 : 1;`
`144`	`146`	`}`
`145`		`-}`
	`147`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -55,9 +55,12 @@ private MarkdownSpec(IEnumerable<Tuple<string, MarkdownDocument>> sources, Repor`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`		`- public static MarkdownSpec ReadFiles(IEnumerable<string> files, Reporter reporter, Func<string, TextReader> readerProvider = null)`
	`58`	`+ public static MarkdownSpec ReadFiles(IEnumerable<string> files, Reporter reporter, Func<string, TextReader>? readerProvider = null)`
`59`	`59`	`{`
`60`		`- if (files is null) throw new ArgumentNullException(nameof(files));`
	`60`	`+ if (files is null)`
	`61`	`+ {`
	`62`	`+ throw new ArgumentNullException(nameof(files));`
	`63`	`+ }`
`61`	`64`
`62`	`65`	`readerProvider ??= File.OpenText;`
`63`	`66`
Original file line number	Diff line number	Diff line change
`@@ -18,14 +18,14 @@ public class Reporter`
`18`	`18`	`/// <summary>`
`19`	`19`	`/// The parent reporter, if any. (This is to allow a complete error/warning count to be kept.)`
`20`	`20`	`/// </summary>`
`21`		`- private readonly Reporter parent;`
	`21`	`+ private readonly Reporter? parent;`
`22`	`22`
`23`	`23`	`public int Errors { get; private set; }`
`24`	`24`	`public int Warnings { get; private set; }`
`25`	`25`
`26`	`26`	`public SourceLocation Location { get; set; } = new SourceLocation(null, null, null, null);`
`27`	`27`
`28`		`- private Reporter(Reporter parent, TextWriter writer, string filename)`
	`28`	`+ private Reporter(Reporter? parent, TextWriter writer, string? filename)`
`29`	`29`	`{`
`30`	`30`	`this.parent = parent;`
`31`	`31`	`this.writer = writer;`
`@@ -38,33 +38,33 @@ public Reporter(TextWriter writer) : this(null, writer, null)`
`38`	`38`
`39`	`39`	`public Reporter WithFileName(string filename) => new Reporter(this, writer, filename);`
`40`	`40`
`41`		`- public string CurrentFile => Location.File;`
	`41`	`+ public string? CurrentFile => Location.File;`
`42`	`42`
`43`		`- public SectionRef CurrentSection`
	`43`	`+ public SectionRef? CurrentSection`
`44`	`44`	`{`
`45`	`45`	`get => Location.Section;`
`46`	`46`	`set => Location = new SourceLocation(CurrentFile, value, CurrentParagraph, null);`
`47`	`47`	`}`
`48`	`48`
`49`		`- public MarkdownParagraph CurrentParagraph`
	`49`	`+ public MarkdownParagraph? CurrentParagraph`
`50`	`50`	`{`
`51`	`51`	`get => Location.Paragraph;`
`52`	`52`	`set => Location = new SourceLocation(CurrentFile, CurrentSection, value, null);`
`53`	`53`	`}`
`54`	`54`
`55`		`- public MarkdownSpan CurrentSpan`
	`55`	`+ public MarkdownSpan? CurrentSpan`
`56`	`56`	`{`
`57`	`57`	`get => Location.Span;`
`58`	`58`	`set => Location = new SourceLocation(CurrentFile, CurrentSection, CurrentParagraph, value);`
`59`	`59`	`}`
`60`	`60`
`61`		`- public void Error(string code, string msg, SourceLocation loc = null)`
	`61`	`+ public void Error(string code, string msg, SourceLocation? loc = null)`
`62`	`62`	`{`
`63`	`63`	`IncrementErrors();`
`64`	`64`	`Report(code, "ERROR", msg, loc?.Description ?? Location.Description);`
`65`	`65`	`}`
`66`	`66`
`67`		`- public void Warning(string code, string msg, SourceLocation loc = null)`
	`67`	`+ public void Warning(string code, string msg, SourceLocation? loc = null)`
`68`	`68`	`{`
`69`	`69`	`IncrementWarnings();`
`70`	`70`	`Report(code, "WARNING", msg, loc?.Description ?? Location.Description);`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ public class SectionRef`
`7`	`7`	`/// <summary>`
`8`	`8`	`/// Section number, e.g. 10.1.2, or A.3 or null for sections without a number (e.g. Foreword).`
`9`	`9`	`/// </summary>`
`10`		`- public string Number { get; }`
	`10`	`+ public string? Number { get; }`
`11`	`11`
`12`	`12`	`/// <summary>`
`13`	`13`	`/// Section title, e.g. "10.1.2 Goto Statement"`
`@@ -43,9 +43,9 @@ public SectionRef(MarkdownParagraph.Heading mdh, string filename, string bookmar`
`43`	`43`	`{`
`44`	`44`	`Level = mdh.size;`
`45`	`45`	`var spans = mdh.body;`
`46`		`- if (spans.Length == 1 && spans.First().IsLiteral)`
	`46`	`+ if (spans.Length == 1 && spans.First() is MarkdownSpan.Literal literal)`
`47`	`47`	`{`
`48`		`- Title = MarkdownUtilities.UnescapeLiteral(spans.First() as MarkdownSpan.Literal).Trim();`
	`48`	`+ Title = MarkdownUtilities.UnescapeLiteral(literal).Trim();`
`49`	`49`	`if (char.IsDigit(Title[0]) \|\| (Title[0] >= 'A' && Title[0] <= 'D' && Title[1] == '.'))`
`50`	`50`	`{`
`51`	`51`	`var titleParts = Title.Split(new[] { ' ' }, 2);`
Original file line number	Diff line number	Diff line change
`@@ -6,13 +6,13 @@ namespace MarkdownConverter.Spec;`
`6`	`6`
`7`	`7`	`public class SourceLocation`
`8`	`8`	`{`
`9`		`- public string File { get; }`
`10`		`- public SectionRef Section { get; }`
`11`		`- public MarkdownParagraph Paragraph { get; }`
`12`		`- public MarkdownSpan Span { get; }`
`13`		`- public string _loc; // generated lazily.`
	`9`	`+ public string? File { get; }`
	`10`	`+ public SectionRef? Section { get; }`
	`11`	`+ public MarkdownParagraph? Paragraph { get; }`
	`12`	`+ public MarkdownSpan? Span { get; }`
	`13`	`+ public string? _loc; // generated lazily.`
`14`	`14`
`15`		`- public SourceLocation(string file, SectionRef section, MarkdownParagraph paragraph, MarkdownSpan span)`
	`15`	`+ public SourceLocation(string? file, SectionRef? section, MarkdownParagraph? paragraph, MarkdownSpan? span)`
`16`	`16`	`{`
`17`	`17`	`File = file;`
`18`	`18`	`Section = section;`
`@@ -42,19 +42,21 @@ public string Description`
`42`	`42`	`}`
`43`	`43`	`else`
`44`	`44`	`{`
	`45`	`+ // TODO: Revisit all of the null-forgiving operator usage here at some point.`
	`46`	`+`
`45`	`47`	`// Note: we now use the F# Markdown support for ranges, rather than finding text directly.`
`46`	`48`	`// This produces slightly weaker diagnostics than before, but it avoids an awful lot of fiddly fuzzy text matching code.`
`47`	`49`
`48`	`50`	`// TODO: Revisit SectionRef.Loc, possibly just exposing the paragraph directly.`
`49`		`- var maybeRange = GetRange(Span);`
	`51`	`+ var maybeRange = GetRange(Span!);`
`50`	`52`	`if (maybeRange != null)`
`51`	`53`	`{`
`52`	`54`	`var range = maybeRange.Value;`
`53`	`55`	`_loc = $"{File}({range.StartLine},{range.StartColumn},{range.EndLine},{range.EndColumn})";`
`54`	`56`	`}`
`55`	`57`	`else`
`56`	`58`	`{`
`57`		`- maybeRange = GetRange(Paragraph) ?? GetRange(Section.Loc.Paragraph);`
	`59`	`+ maybeRange = GetRange(Paragraph!) ?? GetRange(Section!.Loc.Paragraph!);`
`58`	`60`	`if (maybeRange == null)`
`59`	`61`	`{`
`60`	`62`	`// We don't have any line or column information. Just report the filename.`