diff --git a/src/DocoptNet/CodeGeneration/SourceGenerator.cs b/src/DocoptNet/CodeGeneration/SourceGenerator.cs
index 05054fc..0c7b53c 100644
--- a/src/DocoptNet/CodeGeneration/SourceGenerator.cs
+++ b/src/DocoptNet/CodeGeneration/SourceGenerator.cs
@@ -166,7 +166,7 @@ public void Execute(GeneratorExecutionContext context)
                     if (Generate(ns, name, parentNames, attribute?.HelpConstName, help, options) is { Length: > 0 } source)
                     {
                         hintNameBuilder.Clear();
-                        if (ns is { } someNamespace)
+                        if (ns?.Trim() is { Length: > 0 } someNamespace)
                             hintNameBuilder.Append(someNamespace).Append('.');
                         if (parentNames.Length > 0)
                         {
diff --git a/tests/DocoptNet.Tests/CodeGeneration/SourceGeneratorTests.cs b/tests/DocoptNet.Tests/CodeGeneration/SourceGeneratorTests.cs
index cadf378..a41239f 100644
--- a/tests/DocoptNet.Tests/CodeGeneration/SourceGeneratorTests.cs
+++ b/tests/DocoptNet.Tests/CodeGeneration/SourceGeneratorTests.cs
@@ -54,6 +54,17 @@ public void Generate_with_usage_in_external_file()
             });
         }
 
+        [Test]
+        public void Generate_with_empty_root_namespace()
+        {
+            AssertMatchesSnapshot(
+                analyzerConfigOptions: new(KeyValuePair.Create("build_property.RootNamespace", string.Empty)),
+                sources: new[]
+            {
+                ("Program.docopt.txt", SourceText.From(NavalFateUsage))
+            });
+        }
+
         [Test]
         public void Generate_with_inline_usage()
         {
@@ -256,9 +267,10 @@ sealed partial class ProgramArguments
         }
 
         void AssertMatchesSnapshot((string Path, SourceText Text)[] sources,
+                                   AnalyzerConfigOptions? analyzerConfigOptions = null,
                                    [CallerMemberName]string? callerName = null)
         {
-            var (driver, compilation) = PrepareForGeneration(sources);
+            var (driver, compilation) = PrepareForGeneration(analyzerConfigOptions ?? new(), sources);
 
             var grr = driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out _)
                             .GetRunResult().Results.Single();
@@ -340,7 +352,16 @@ where Path.GetFileName(fp) is { } fn
                        || fn.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
                 select Path.GetRelativePath(solutionDirPath, fp);
 
-            var actualFiles = EnumerateFiles(actualSourcesPath);
+            var actualFiles = EnumerateFiles(actualSourcesPath).ToImmutableArray();
+
+            Assert.That(from gs in grr.GeneratedSources
+                        orderby gs.HintName
+                        select gs.HintName,
+                        Is.EqualTo(from af in actualFiles
+                                   select Path.GetFileName(af) into af
+                                   where af.EndsWith(".cs", StringComparison.OrdinalIgnoreCase)
+                                   orderby af
+                                   select af));
 
             var expectedFiles = Directory.Exists(expectedSourcesPath)
                               ? EnumerateFiles(expectedSourcesPath)
@@ -553,7 +574,12 @@ public partial class " + ProgramArgumentsClassName + @" { }
             new AnalyzerConfigOptions(KeyValuePair.Create("build_metadata.AdditionalFiles.SourceItemType", "Docopt"));
 
         internal static (CSharpGeneratorDriver, CSharpCompilation)
-            PrepareForGeneration(params (string Path, SourceText Text)[] sources)
+            PrepareForGeneration(params (string Path, SourceText Text)[] sources) =>
+            PrepareForGeneration(new AnalyzerConfigOptions(), sources);
+
+        internal static (CSharpGeneratorDriver, CSharpCompilation)
+            PrepareForGeneration(AnalyzerConfigOptions analyzerConfigOptions,
+                                 params (string Path, SourceText Text)[] sources)
         {
             var trees = new List<SyntaxTree>();
             var additionalTexts = new List<AdditionalText>();
@@ -579,11 +605,9 @@ internal static (CSharpGeneratorDriver, CSharpCompilation)
 
             ISourceGenerator generator = new SourceGenerator();
 
-            var globalOptions = Enumerable.Empty<KeyValuePair<string, string>>();
-
             var optionsProvider =
                 new AnalyzerConfigOptionsProvider(
-                    new AnalyzerConfigOptions(globalOptions),
+                    analyzerConfigOptions,
                     additionalTexts.Select(at => KeyValuePair.Create(at, DocoptSourceItemTypeConfigOption))
                                    .ToImmutableDictionary());
 
diff --git a/tests/DocoptNet.Tests/CodeGeneration/SourceGeneratorTests/Generate_with_empty_root_namespace/ProgramArguments.cs b/tests/DocoptNet.Tests/CodeGeneration/SourceGeneratorTests/Generate_with_empty_root_namespace/ProgramArguments.cs
new file mode 100644
index 0000000..5f10428
--- /dev/null
+++ b/tests/DocoptNet.Tests/CodeGeneration/SourceGeneratorTests/Generate_with_empty_root_namespace/ProgramArguments.cs
@@ -0,0 +1,492 @@
+// <auto-generated/>
+
+#nullable enable
+
+using System.Collections;
+using System.Collections.Generic;
+using DocoptNet;
+using DocoptNet.Internals;
+using Leaves = DocoptNet.Internals.ReadOnlyList<DocoptNet.Internals.LeafPattern>;
+
+partial class ProgramArguments : IEnumerable<KeyValuePair<string, object?>>
+{
+    public const string Help = @"
+Naval Fate.
+
+    Usage:
+      naval_fate.exe ship new <name>...
+      naval_fate.exe ship <name> move <x> <y> [--speed=<kn>]
+      naval_fate.exe ship shoot <x> <y>
+      naval_fate.exe mine (set|remove) <x> <y> [--moored | --drifting]
+      naval_fate.exe (-h | --help)
+      naval_fate.exe --version
+
+    Options:
+      -h --help     Show this screen.
+      --version     Show version.
+      --speed=<kn>  Speed in knots [default: 10].
+      --moored      Moored (anchored) mine.
+      --drifting    Drifting mine.
+";
+
+    public const string Usage = @"Usage:
+      naval_fate.exe ship new <name>...
+      naval_fate.exe ship <name> move <x> <y> [--speed=<kn>]
+      naval_fate.exe ship shoot <x> <y>
+      naval_fate.exe mine (set|remove) <x> <y> [--moored | --drifting]
+      naval_fate.exe (-h | --help)
+      naval_fate.exe --version";
+
+    static readonly IHelpFeaturingParser<ProgramArguments> Parser = GeneratedSourceModule.CreateParser(Help, Parse).EnableHelp();
+
+    public static IHelpFeaturingParser<ProgramArguments> CreateParser() => Parser;
+
+    static IParser<ProgramArguments>.IResult Parse(IEnumerable<string> args, ParseFlags flags, string? version)
+    {
+        var options = new List<Option>
+        {
+            new("-h", "--help", 0, false),
+            new("--version", 0, false),
+            new("--speed", 1, "10"),
+            new("--moored", 0, false),
+            new("--drifting", 0, false),
+        };
+
+        return GeneratedSourceModule.Parse(Help, Usage, args, options, flags, version, Parse);
+
+        static IParser<ProgramArguments>.IResult Parse(Leaves left)
+        {
+            var required = new RequiredMatcher(1, left, new Leaves());
+            Match(ref required);
+            if (!required.Result || required.Left.Count > 0)
+            {
+                return GeneratedSourceModule.CreateInputErrorResult<ProgramArguments>(string.Empty, Usage);
+            }
+            var collected = required.Collected;
+            var result = new ProgramArguments();
+
+            foreach (var leaf in collected)
+            {
+                var value = leaf.Value is { IsStringList: true } ? ((StringList)leaf.Value).Reverse() : leaf.Value;
+                switch (leaf.Name)
+                {
+                    case "ship": result.CmdShip = (bool)value; break;
+                    case "new": result.CmdNew = (bool)value; break;
+                    case "<name>": result.ArgName = (StringList)value; break;
+                    case "move": result.CmdMove = (bool)value; break;
+                    case "<x>": result.ArgX = (string?)value; break;
+                    case "<y>": result.ArgY = (string?)value; break;
+                    case "--speed": result.OptSpeed = (string)value; break;
+                    case "shoot": result.CmdShoot = (bool)value; break;
+                    case "mine": result.CmdMine = (bool)value; break;
+                    case "set": result.CmdSet = (bool)value; break;
+                    case "remove": result.CmdRemove = (bool)value; break;
+                    case "--moored": result.OptMoored = (bool)value; break;
+                    case "--drifting": result.OptDrifting = (bool)value; break;
+                    case "--help": result.OptHelp = (bool)value; break;
+                    case "--version": result.OptVersion = (bool)value; break;
+                }
+            }
+
+            return GeneratedSourceModule.CreateArgumentsResult(result);
+        }
+
+        static void Match(ref RequiredMatcher required)
+        {
+            // Required(Either(Required(Command(ship, False), Command(new, False), OneOrMore(Argument(<name>, []))), Required(Command(ship, False), Argument(<name>, []), Command(move, False), Argument(<x>, ), Argument(<y>, ), Optional(Option(,--speed,1,10))), Required(Command(ship, False), Command(shoot, False), Argument(<x>, ), Argument(<y>, )), Required(Command(mine, False), Required(Either(Command(set, False), Command(remove, False))), Argument(<x>, ), Argument(<y>, ), Optional(Either(Option(,--moored,0,False), Option(,--drifting,0,False)))), Required(Required(Option(-h,--help,0,False))), Required(Option(,--version,0,False))))
+            var a = new RequiredMatcher(1, required.Left, required.Collected);
+            while (a.Next())
+            {
+                // Either(Required(Command(ship, False), Command(new, False), OneOrMore(Argument(<name>, []))), Required(Command(ship, False), Argument(<name>, []), Command(move, False), Argument(<x>, ), Argument(<y>, ), Optional(Option(,--speed,1,10))), Required(Command(ship, False), Command(shoot, False), Argument(<x>, ), Argument(<y>, )), Required(Command(mine, False), Required(Either(Command(set, False), Command(remove, False))), Argument(<x>, ), Argument(<y>, ), Optional(Either(Option(,--moored,0,False), Option(,--drifting,0,False)))), Required(Required(Option(-h,--help,0,False))), Required(Option(,--version,0,False)))
+                var b = new EitherMatcher(6, a.Left, a.Collected);
+                while (b.Next())
+                {
+                    switch (b.Index)
+                    {
+                        case 0:
+                        {
+                            // Required(Command(ship, False), Command(new, False), OneOrMore(Argument(<name>, [])))
+                            var c = new RequiredMatcher(3, b.Left, b.Collected);
+                            while (c.Next())
+                            {
+                                switch (c.Index)
+                                {
+                                    case 0:
+                                    {
+                                        // Command(ship, False)
+                                        c.Match(PatternMatcher.MatchCommand, "ship", ArgValueKind.Boolean);
+                                    }
+                                    break;
+                                    case 1:
+                                    {
+                                        // Command(new, False)
+                                        c.Match(PatternMatcher.MatchCommand, "new", ArgValueKind.Boolean);
+                                    }
+                                    break;
+                                    case 2:
+                                    {
+                                        // OneOrMore(Argument(<name>, []))
+                                        var d = new OneOrMoreMatcher(1, c.Left, c.Collected);
+                                        while (d.Next())
+                                        {
+                                            // Argument(<name>, [])
+                                            d.Match(PatternMatcher.MatchArgument, "<name>", ArgValueKind.StringList);
+                                            if (!d.LastMatched)
+                                            {
+                                                break;
+                                            }
+                                        }
+                                        c.Fold(d.Result);
+                                    }
+                                    break;
+                                }
+                                if (!c.LastMatched)
+                                {
+                                    break;
+                                }
+                            }
+                            b.Fold(c.Result);
+                        }
+                        break;
+                        case 1:
+                        {
+                            // Required(Command(ship, False), Argument(<name>, []), Command(move, False), Argument(<x>, ), Argument(<y>, ), Optional(Option(,--speed,1,10)))
+                            var c = new RequiredMatcher(6, b.Left, b.Collected);
+                            while (c.Next())
+                            {
+                                switch (c.Index)
+                                {
+                                    case 0:
+                                    {
+                                        // Command(ship, False)
+                                        c.Match(PatternMatcher.MatchCommand, "ship", ArgValueKind.Boolean);
+                                    }
+                                    break;
+                                    case 1:
+                                    {
+                                        // Argument(<name>, [])
+                                        c.Match(PatternMatcher.MatchArgument, "<name>", ArgValueKind.StringList);
+                                    }
+                                    break;
+                                    case 2:
+                                    {
+                                        // Command(move, False)
+                                        c.Match(PatternMatcher.MatchCommand, "move", ArgValueKind.Boolean);
+                                    }
+                                    break;
+                                    case 3:
+                                    {
+                                        // Argument(<x>, )
+                                        c.Match(PatternMatcher.MatchArgument, "<x>", ArgValueKind.None);
+                                    }
+                                    break;
+                                    case 4:
+                                    {
+                                        // Argument(<y>, )
+                                        c.Match(PatternMatcher.MatchArgument, "<y>", ArgValueKind.None);
+                                    }
+                                    break;
+                                    case 5:
+                                    {
+                                        // Optional(Option(,--speed,1,10))
+                                        var d = new OptionalMatcher(1, c.Left, c.Collected);
+                                        while (d.Next())
+                                        {
+                                            // Option(,--speed,1,10)
+                                            d.Match(PatternMatcher.MatchOption, "--speed", ArgValueKind.String);
+                                            if (!d.LastMatched)
+                                            {
+                                                break;
+                                            }
+                                        }
+                                        c.Fold(d.Result);
+                                    }
+                                    break;
+                                }
+                                if (!c.LastMatched)
+                                {
+                                    break;
+                                }
+                            }
+                            b.Fold(c.Result);
+                        }
+                        break;
+                        case 2:
+                        {
+                            // Required(Command(ship, False), Command(shoot, False), Argument(<x>, ), Argument(<y>, ))
+                            var c = new RequiredMatcher(4, b.Left, b.Collected);
+                            while (c.Next())
+                            {
+                                switch (c.Index)
+                                {
+                                    case 0:
+                                    {
+                                        // Command(ship, False)
+                                        c.Match(PatternMatcher.MatchCommand, "ship", ArgValueKind.Boolean);
+                                    }
+                                    break;
+                                    case 1:
+                                    {
+                                        // Command(shoot, False)
+                                        c.Match(PatternMatcher.MatchCommand, "shoot", ArgValueKind.Boolean);
+                                    }
+                                    break;
+                                    case 2:
+                                    {
+                                        // Argument(<x>, )
+                                        c.Match(PatternMatcher.MatchArgument, "<x>", ArgValueKind.None);
+                                    }
+                                    break;
+                                    case 3:
+                                    {
+                                        // Argument(<y>, )
+                                        c.Match(PatternMatcher.MatchArgument, "<y>", ArgValueKind.None);
+                                    }
+                                    break;
+                                }
+                                if (!c.LastMatched)
+                                {
+                                    break;
+                                }
+                            }
+                            b.Fold(c.Result);
+                        }
+                        break;
+                        case 3:
+                        {
+                            // Required(Command(mine, False), Required(Either(Command(set, False), Command(remove, False))), Argument(<x>, ), Argument(<y>, ), Optional(Either(Option(,--moored,0,False), Option(,--drifting,0,False))))
+                            var c = new RequiredMatcher(5, b.Left, b.Collected);
+                            while (c.Next())
+                            {
+                                switch (c.Index)
+                                {
+                                    case 0:
+                                    {
+                                        // Command(mine, False)
+                                        c.Match(PatternMatcher.MatchCommand, "mine", ArgValueKind.Boolean);
+                                    }
+                                    break;
+                                    case 1:
+                                    {
+                                        // Required(Either(Command(set, False), Command(remove, False)))
+                                        var d = new RequiredMatcher(1, c.Left, c.Collected);
+                                        while (d.Next())
+                                        {
+                                            // Either(Command(set, False), Command(remove, False))
+                                            var e = new EitherMatcher(2, d.Left, d.Collected);
+                                            while (e.Next())
+                                            {
+                                                switch (e.Index)
+                                                {
+                                                    case 0:
+                                                    {
+                                                        // Command(set, False)
+                                                        e.Match(PatternMatcher.MatchCommand, "set", ArgValueKind.Boolean);
+                                                    }
+                                                    break;
+                                                    case 1:
+                                                    {
+                                                        // Command(remove, False)
+                                                        e.Match(PatternMatcher.MatchCommand, "remove", ArgValueKind.Boolean);
+                                                    }
+                                                    break;
+                                                }
+                                                if (!e.LastMatched)
+                                                {
+                                                    break;
+                                                }
+                                            }
+                                            d.Fold(e.Result);
+                                            if (!d.LastMatched)
+                                            {
+                                                break;
+                                            }
+                                        }
+                                        c.Fold(d.Result);
+                                    }
+                                    break;
+                                    case 2:
+                                    {
+                                        // Argument(<x>, )
+                                        c.Match(PatternMatcher.MatchArgument, "<x>", ArgValueKind.None);
+                                    }
+                                    break;
+                                    case 3:
+                                    {
+                                        // Argument(<y>, )
+                                        c.Match(PatternMatcher.MatchArgument, "<y>", ArgValueKind.None);
+                                    }
+                                    break;
+                                    case 4:
+                                    {
+                                        // Optional(Either(Option(,--moored,0,False), Option(,--drifting,0,False)))
+                                        var d = new OptionalMatcher(1, c.Left, c.Collected);
+                                        while (d.Next())
+                                        {
+                                            // Either(Option(,--moored,0,False), Option(,--drifting,0,False))
+                                            var e = new EitherMatcher(2, d.Left, d.Collected);
+                                            while (e.Next())
+                                            {
+                                                switch (e.Index)
+                                                {
+                                                    case 0:
+                                                    {
+                                                        // Option(,--moored,0,False)
+                                                        e.Match(PatternMatcher.MatchOption, "--moored", ArgValueKind.Boolean);
+                                                    }
+                                                    break;
+                                                    case 1:
+                                                    {
+                                                        // Option(,--drifting,0,False)
+                                                        e.Match(PatternMatcher.MatchOption, "--drifting", ArgValueKind.Boolean);
+                                                    }
+                                                    break;
+                                                }
+                                                if (!e.LastMatched)
+                                                {
+                                                    break;
+                                                }
+                                            }
+                                            d.Fold(e.Result);
+                                            if (!d.LastMatched)
+                                            {
+                                                break;
+                                            }
+                                        }
+                                        c.Fold(d.Result);
+                                    }
+                                    break;
+                                }
+                                if (!c.LastMatched)
+                                {
+                                    break;
+                                }
+                            }
+                            b.Fold(c.Result);
+                        }
+                        break;
+                        case 4:
+                        {
+                            // Required(Required(Option(-h,--help,0,False)))
+                            var c = new RequiredMatcher(1, b.Left, b.Collected);
+                            while (c.Next())
+                            {
+                                // Required(Option(-h,--help,0,False))
+                                var d = new RequiredMatcher(1, c.Left, c.Collected);
+                                while (d.Next())
+                                {
+                                    // Option(-h,--help,0,False)
+                                    d.Match(PatternMatcher.MatchOption, "--help", ArgValueKind.Boolean);
+                                    if (!d.LastMatched)
+                                    {
+                                        break;
+                                    }
+                                }
+                                c.Fold(d.Result);
+                                if (!c.LastMatched)
+                                {
+                                    break;
+                                }
+                            }
+                            b.Fold(c.Result);
+                        }
+                        break;
+                        case 5:
+                        {
+                            // Required(Option(,--version,0,False))
+                            var c = new RequiredMatcher(1, b.Left, b.Collected);
+                            while (c.Next())
+                            {
+                                // Option(,--version,0,False)
+                                c.Match(PatternMatcher.MatchOption, "--version", ArgValueKind.Boolean);
+                                if (!c.LastMatched)
+                                {
+                                    break;
+                                }
+                            }
+                            b.Fold(c.Result);
+                        }
+                        break;
+                    }
+                    if (!b.LastMatched)
+                    {
+                        break;
+                    }
+                }
+                a.Fold(b.Result);
+                if (!a.LastMatched)
+                {
+                    break;
+                }
+            }
+            required.Fold(a.Result);
+        }
+    }
+
+    IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
+    {
+        yield return KeyValuePair.Create("ship", (object?)CmdShip);
+        yield return KeyValuePair.Create("new", (object?)CmdNew);
+        yield return KeyValuePair.Create("<name>", (object?)ArgName);
+        yield return KeyValuePair.Create("move", (object?)CmdMove);
+        yield return KeyValuePair.Create("<x>", (object?)ArgX);
+        yield return KeyValuePair.Create("<y>", (object?)ArgY);
+        yield return KeyValuePair.Create("--speed", (object?)OptSpeed);
+        yield return KeyValuePair.Create("shoot", (object?)CmdShoot);
+        yield return KeyValuePair.Create("mine", (object?)CmdMine);
+        yield return KeyValuePair.Create("set", (object?)CmdSet);
+        yield return KeyValuePair.Create("remove", (object?)CmdRemove);
+        yield return KeyValuePair.Create("--moored", (object?)OptMoored);
+        yield return KeyValuePair.Create("--drifting", (object?)OptDrifting);
+        yield return KeyValuePair.Create("--help", (object?)OptHelp);
+        yield return KeyValuePair.Create("--version", (object?)OptVersion);
+    }
+
+    IEnumerator<KeyValuePair<string, object?>> IEnumerable<KeyValuePair<string, object?>>.GetEnumerator() => GetEnumerator();
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+    /// <summary><c>Command(ship, False)</c></summary>
+    public bool CmdShip { get; private set; }
+
+    /// <summary><c>Command(new, False)</c></summary>
+    public bool CmdNew { get; private set; }
+
+    /// <summary><c>Argument(&lt;name&gt;, [])</c></summary>
+    public StringList ArgName { get; private set; } = StringList.Empty;
+
+    /// <summary><c>Command(move, False)</c></summary>
+    public bool CmdMove { get; private set; }
+
+    /// <summary><c>Argument(&lt;x&gt;, )</c></summary>
+    public string? ArgX { get; private set; }
+
+    /// <summary><c>Argument(&lt;y&gt;, )</c></summary>
+    public string? ArgY { get; private set; }
+
+    /// <summary><c>Option(,--speed,1,10)</c></summary>
+    public string OptSpeed { get; private set; } = "10";
+
+    /// <summary><c>Command(shoot, False)</c></summary>
+    public bool CmdShoot { get; private set; }
+
+    /// <summary><c>Command(mine, False)</c></summary>
+    public bool CmdMine { get; private set; }
+
+    /// <summary><c>Command(set, False)</c></summary>
+    public bool CmdSet { get; private set; }
+
+    /// <summary><c>Command(remove, False)</c></summary>
+    public bool CmdRemove { get; private set; }
+
+    /// <summary><c>Option(,--moored,0,False)</c></summary>
+    public bool OptMoored { get; private set; }
+
+    /// <summary><c>Option(,--drifting,0,False)</c></summary>
+    public bool OptDrifting { get; private set; }
+
+    /// <summary><c>Option(-h,--help,0,False)</c></summary>
+    public bool OptHelp { get; private set; }
+
+    /// <summary><c>Option(,--version,0,False)</c></summary>
+    public bool OptVersion { get; private set; }
+}