Added Channel to generator so loading and generating run in parallel

Triogap · Triogap · commit 55140955fb73 · 2025-05-30T20:00:34.000+02:00
diff --git a/Generator/CodeGenerator.cs b/Generator/CodeGenerator.cs
@@ -1,37 +1,20 @@
 ﻿using System.Text;
+using System.Threading.Channels;
 namespace System.Management.Generator;
 
-public class CodeGenerator
+public class CodeGenerator(ChannelReader<ClassDefinition> channel)
 {
     private static readonly HashSet<string> _excludedFolders = new(StringComparer.OrdinalIgnoreCase) { "bin", "obj" };
 
-    private static DirectoryInfo FindTypesDirectory()
-    {
-        var dir = new DirectoryInfo(Environment.CurrentDirectory);
-        while (dir != null)
-        {
-            var typesDir = new DirectoryInfo(Path.Combine(dir.FullName, "Types"));
-            if (typesDir.Exists)
-                return typesDir;
-            dir = dir.Parent;
-        }
-        throw new DirectoryNotFoundException("Could not find 'Types' directory in any parent directory.");
-    }
+    private readonly DirectoryInfo _targetDirectory = FindTypesDirectory();;
+    private readonly Dictionary<string, ClassDefinition> _classDefinitions = new(StringComparer.OrdinalIgnoreCase);
 
-    private readonly Dictionary<string, ClassDefinition> _classDefinitions;
-    private readonly DirectoryInfo _targetDirectory;
-
-    public CodeGenerator(IEnumerable<ClassDefinition> classDefinitions)
-    {
-        _classDefinitions = classDefinitions.ToDictionary(t => t.ClassName, t => t, StringComparer.InvariantCultureIgnoreCase);
-        _targetDirectory = FindTypesDirectory();
-    }
-
-    public void GenerateCode()
+    public async Task GenerateCode()
     {
         var existingFiles = _targetDirectory.GetDirectories().Where(d => !_excludedFolders.Contains(d.Name)).SelectMany(d => d.GetFiles("*.g.cs", SearchOption.AllDirectories)).Select(fi => fi.FullName).ToHashSet(StringComparer.OrdinalIgnoreCase);
-        foreach (var typeDefinition in _classDefinitions.Values)
+        await foreach (var typeDefinition in channel.ReadAllAsync())
         {
+            _classDefinitions[typeDefinition.ClassName] = typeDefinition;
             Console.WriteLine($"Generating class for {typeDefinition.ClassName}.");
             (var namespaceName, var className) = ParseClassName(typeDefinition.ClassName);
 
@@ -92,6 +75,19 @@ public void GenerateCode()
         }
     }
 
+    private static DirectoryInfo FindTypesDirectory()
+    {
+        var dir = new DirectoryInfo(Environment.CurrentDirectory);
+        while (dir != null)
+        {
+            var typesDir = new DirectoryInfo(Path.Combine(dir.FullName, "Types"));
+            if (typesDir.Exists)
+                return typesDir;
+            dir = dir.Parent;
+        }
+        throw new DirectoryNotFoundException("Could not find 'Types' directory in any parent directory.");
+    }
+
     private IEnumerable<PropertyDefinition> GetInheritedPropertiesFrom(string? superClass)
         => superClass != null && _classDefinitions.TryGetValue(superClass, out var td) ? td.Properties.Concat(GetInheritedPropertiesFrom(td.SuperClass)) : [];
 
diff --git a/Generator/DefinitionLoader.cs b/Generator/DefinitionLoader.cs
@@ -1,8 +1,9 @@
 ﻿using System.Diagnostics.CodeAnalysis;
 using System.Text.RegularExpressions;
+using System.Threading.Channels;
 namespace System.Management.Generator;
 
-internal partial class DefinitionLoader(IEnumerable<string> classNames)
+internal partial class DefinitionLoader(ChannelWriter<ClassDefinition> channel)
 {
 
     [GeneratedRegex(@"<code class=""lang-syntax"">([^<]*)</code>")]
@@ -33,68 +34,56 @@ internal partial class DefinitionLoader(IEnumerable<string> classNames)
     private static partial Regex GetLinkRegex();
     private static readonly Regex LinkRegex = GetLinkRegex();
 
-    private readonly Dictionary<string, ClassDefinition> _classDefinitions = classNames.ToDictionary(n => n, n => default(ClassDefinition), StringComparer.OrdinalIgnoreCase);
-    public IEnumerable<ClassDefinition> LoadedClassDefinitions => _classDefinitions.Values;
+    private readonly Dictionary<string, string> _typeMismatches = new() { ["Win32_LogicalElement"] = "CIM_LogicalElement" };
+    private readonly HashSet<string> _loadedClassDefinitions = new(StringComparer.OrdinalIgnoreCase);
 
-    private string? CheckClass(string? className)
+    public async Task Load(IEnumerable<string> classesToLoad)
     {
-        if (className == null)
+        foreach (var className in classesToLoad)
         {
-            return null;
+            await TryLoadClass(className);
         }
 
-        if ("Win32_LogicalElement".Equals(className))
+        channel.Complete();
+    }
+
+    private async Task<string?> TryLoadClass(string? className)
+    {
+        if (className == null)
         {
-            return CheckClass("CIM_LogicalElement");
+            return null;
         }
 
-        if (!_classDefinitions.ContainsKey(className))
+        if (_typeMismatches.TryGetValue(className, out var correctClassName))
         {
-            if (className.IndexOf('_') == -1)
-            {
-                return CheckClass($"__{className}");
-            }
-
-            _classDefinitions.Add(className, default);
-            Console.WriteLine($"Met new class {className}.");
+            return await TryLoadClass(correctClassName);
         }
-        return className;
-    }
 
-    public async Task Load()
-    {
-        foreach (var className in GetUnloadedClassNames())
+        if (_loadedClassDefinitions.Add(className))
         {
             if (await LoadClassDefinition(className) is ClassDefinition classDefinition)
             {
-                _classDefinitions[className] = classDefinition;
+                Console.WriteLine($"Loaded info for {className}:");
+                await channel.WriteAsync(classDefinition);
+                return className;
             }
-            else
+            else if (className.IndexOf('_') == -1)
             {
-                _classDefinitions.Remove(className);
+                var prefixedClassName = $"__{className}";
+                _typeMismatches[className] = prefixedClassName;
+                return await TryLoadClass(prefixedClassName);
             }
         }
-    }
 
-    private IEnumerable<string> GetUnloadedClassNames()
-    {
-        var classNames = _classDefinitions.Where(kvp => kvp.Value.ClassName == null).Select(kvp => kvp.Key).ToArray();
-        while (classNames.Length > 0)
-        {
-            foreach (var className in classNames)
-            {
-                yield return className;
-            }
-            classNames = _classDefinitions.Where(kvp => kvp.Value.ClassName == null).Select(kvp => kvp.Key).ToArray();
-        }
+        return null;
     }
 
     private async Task<ClassDefinition?> LoadClassDefinition(string className)
     {
-        Console.WriteLine($"Getting info for {className}:");
+        Console.WriteLine($"Loading info for {className}:");
         Uri? classUri = null;
         Uri[] uris = className[0] == '_'
-            ? [new Uri($"https://learn.microsoft.com/en-gb/windows/win32/wmisdk/{className.Replace('_', '-')}")]
+            ? [new Uri($"https://learn.microsoft.com/en-us/windows/win32/wmisdk/{className.Replace('_', '-')}")]
             : [new Uri($"https://learn.microsoft.com/en-us/windows/win32/cimwin32prov/{className.Replace('_', '-')}"),
                new Uri($"https://learn.microsoft.com/en-us/previous-versions/windows/desktop/secrcw32prov//{className.Replace('_', '-')}")];
 
@@ -111,15 +100,14 @@ private IEnumerable<string> GetUnloadedClassNames()
             {
                 if (i + 1 == uris.Length)
                 {
-                    ErrorReporter.Report($"Unable to find Microsoft Learn page to parse for {className}: {ex.Message}", ex);
+                    ErrorReporter.Report($"Unable to find Microsoft Learn page to parse for {className}: {ex.Message}", ex, throwOrBreak: false);
                     break;
                 }
             }
         }
 
         if (classUri == null || pageContents == null)
         {
-            ErrorReporter.Report($"Failed to load {className}.");
             return null;
         }
 
@@ -151,14 +139,14 @@ private IEnumerable<string> GetUnloadedClassNames()
                 ErrorReporter.Report($"Encounterd different type {classDef[1]} when parsing data for {className}.");
             }
 
-            superClass = CheckClass(classDef.Length > 2 ? classDef[^1] : null);
+            superClass = await TryLoadClass(classDef.Length > 2 ? classDef[^1] : null);
 
             break;
         }
 
         var propertyBlock = pageContents.IndexOf("<h3 id=\"properties\"");
         var endBlock = pageContents.IndexOf("<h3", propertyBlock + 1);
-        var properties = propertyBlock == -1 ? [] : ParseProperties(codeLines[(lineIndex + 2)..^1], pageContents[propertyBlock..endBlock]).ToList();
+        var properties = propertyBlock == -1 ? [] : await ParseProperties(codeLines[(lineIndex + 2)..^1], pageContents[propertyBlock..endBlock]);
 
         var methodBlock = pageContents.IndexOf("<h3 id=\"methods\"");
         endBlock = pageContents.IndexOf("<h3", methodBlock + 1);
@@ -177,31 +165,37 @@ private static async Task<string> GetPageContentsAsync(Uri url)
         return await response.Content.ReadAsStringAsync();
     }
 
-    private IEnumerable<PropertyDefinition> ParseProperties(string[] propertyLines, string propertiesBlock)
+    private async Task<List<PropertyDefinition>> ParseProperties(string[] propertyLines, string propertiesBlock)
     {
-        foreach (var property in propertyLines.Select(ParsePropertyLine).OfType<PropertyDefinition>())
+        var result = new List<PropertyDefinition>(propertyLines.Length);
+        foreach (var propertyLine in propertyLines)
         {
-            if (TryGetPropertyV1(property.Name, propertiesBlock, out var propertyBlock))
+            if (await ParsePropertyLine(propertyLine) is PropertyDefinition property)
             {
-                if (PropertyIsInherited(propertyBlock))
+                if (TryGetPropertyV1(property.Name, propertiesBlock, out var propertyBlock))
                 {
-                    continue;
+                    if (PropertyIsInherited(propertyBlock))
+                    {
+                        continue;
+                    }
+                    result.Add(await UpdatePropertyV1(property, propertyBlock));
                 }
-                yield return UpdatePropertyV1(property, propertyBlock);
-            }
-            else if (TryGetPropertyV2(property.Name, propertiesBlock, out propertyBlock))
-            {
-                if (PropertyIsInherited(propertyBlock))
+                else if (TryGetPropertyV2(property.Name, propertiesBlock, out propertyBlock))
                 {
-                    continue;
+                    if (PropertyIsInherited(propertyBlock))
+                    {
+                        continue;
+                    }
+                    result.Add(await UpdatePropertyV2(property, propertyBlock));
+                }
+                else
+                {
+                    ErrorReporter.Report($"No description found for property {property.Name}.", throwOrBreak: false);
                 }
-                yield return UpdatePropertyV2(property, propertyBlock);
-            }
-            else
-            {
-                ErrorReporter.Report($"No description found for property {property.Name}.", throwOrBreak: false);
             }
         }
+
+        return result;
     }
 
     private static bool TryGetPropertyV1(string propertyName, string propertiesBlock, [MaybeNullWhen(false)]out string propertyBlock)
@@ -235,11 +229,12 @@ private static bool TryGetPropertyV2(string propertyName, string propertiesBlock
     private static bool PropertyIsInherited(string propertyBlock)
         => propertyBlock.Contains("This property is inherited from");
 
-    private PropertyDefinition UpdatePropertyV1(PropertyDefinition property, string propertyBlock)
+    private async Task<PropertyDefinition> UpdatePropertyV1(PropertyDefinition property, string propertyBlock)
     {
         foreach (var paragraph in ParagraphRegex.Matches(propertyBlock).Select(TrimHTML))
         {
-            if (!ParseSubProperty(ref property, paragraph))
+            (var parsed, property) = await ParseSubProperty(property, paragraph);
+            if (!parsed)
             {
                 property = property with { Description = paragraph };
                 break;
@@ -249,11 +244,11 @@ private PropertyDefinition UpdatePropertyV1(PropertyDefinition property, string
         return property;
     }
 
-    private PropertyDefinition UpdatePropertyV2(PropertyDefinition property, string propertyBlock)
+    private async Task<PropertyDefinition> UpdatePropertyV2(PropertyDefinition property, string propertyBlock)
     {
         foreach (var propertyDescription in PropertyRegex.Matches(propertyBlock).Select(TrimHTML))
         {
-            ParseSubProperty(ref property, propertyDescription);
+            (_, property) = await ParseSubProperty(property, propertyDescription);
         }
 
         if (TrimHTML(DescriptionRegex.Match(propertyBlock)) is string description && description.Length > 0)
@@ -264,12 +259,12 @@ private PropertyDefinition UpdatePropertyV2(PropertyDefinition property, string
         return property;
     }
 
-    private bool ParseSubProperty(ref PropertyDefinition property, string paragraph)
+    private async Task<(bool, PropertyDefinition)> ParseSubProperty(PropertyDefinition property, string paragraph)
     {
         var colonIndex = paragraph.IndexOf(':');
         if (colonIndex == -1)
         {
-            return false;
+            return (false, property);
         }
 
         switch (paragraph[..colonIndex])
@@ -289,7 +284,7 @@ private bool ParseSubProperty(ref PropertyDefinition property, string paragraph)
                     }
                     else if (typeName.Contains('_'))
                     {
-                        property = property with { Type = CimType.Reference, ReferencedClass = CheckClass(typeName) };
+                        property = property with { Type = CimType.Reference, ReferencedClass = await TryLoadClass(typeName) };
                     }
                     else
                     {
@@ -314,7 +309,7 @@ private bool ParseSubProperty(ref PropertyDefinition property, string paragraph)
                 property = property with { Qualifiers = ParseQualifiers(paragraph[(colonIndex + 2)..]) };
                 break;
         }
-        return true;
+        return (true, property);
     }
 
     private static List<QualifierDefinition> ParseQualifiers(string qualifiers)
@@ -334,7 +329,7 @@ private static string TrimHTML(string source)
             .Replace("&nbsp;", " ")
             .Trim();
 
-    private PropertyDefinition? ParsePropertyLine(string propertyLine)
+    private async Task<PropertyDefinition?> ParsePropertyLine(string propertyLine)
     {
         var parts = TrimHTML(propertyLine).Split(' ', options: StringSplitOptions.RemoveEmptyEntries);
 
@@ -347,7 +342,7 @@ private static string TrimHTML(string source)
         if (!Enum.TryParse(parts[0], ignoreCase: true, out CimType type) && parts[0].Contains('_'))
         {
             type = CimType.Reference;
-            referenceType = CheckClass(parts[0]);
+            referenceType = await TryLoadClass(parts[0]);
         }
 
         var name = parts[^2][0] == '=' ? parts[^3] : parts[^1];
diff --git a/Generator/Program.cs b/Generator/Program.cs
@@ -1,5 +1,6 @@
 ﻿// See https://aka.ms/new-console-template for more information
 using System.Management.Generator;
+using System.Threading.Channels;
 
 List<string> classes = 
     [ 
@@ -80,7 +81,8 @@
     "Win32_MethodParameterClass", "Win32_WMIElementSetting", "Win32_WMISetting",
 ];
 
-var loader = new DefinitionLoader(classes);
-await loader.Load();
-var generator = new CodeGenerator(loader.LoadedClassDefinitions);
-generator.GenerateCode();
+var channel = Channel.CreateUnbounded<ClassDefinition>();
+
+var loader = new DefinitionLoader(channel.Writer);
+var generator = new CodeGenerator(channel.Reader);
+await Task.WhenAll(loader.Load(classes), generator.GenerateCode());

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,9 @@`
`1`	`1`	`using System.Diagnostics.CodeAnalysis;`
`2`	`2`	`using System.Text.RegularExpressions;`
	`3`	`+using System.Threading.Channels;`
`3`	`4`	`namespace System.Management.Generator;`
`4`	`5`
`5`		`-internal partial class DefinitionLoader(IEnumerable<string> classNames)`
	`6`	`+internal partial class DefinitionLoader(ChannelWriter<ClassDefinition> channel)`
`6`	`7`	`{`
`7`	`8`
`8`	`9`	`[GeneratedRegex(@"<code class=""lang-syntax"">([^<]*)</code>")]`
`@@ -33,68 +34,56 @@ internal partial class DefinitionLoader(IEnumerable<string> classNames)`
`33`	`34`	`private static partial Regex GetLinkRegex();`
`34`	`35`	`private static readonly Regex LinkRegex = GetLinkRegex();`
`35`	`36`
`36`		`- private readonly Dictionary<string, ClassDefinition> _classDefinitions = classNames.ToDictionary(n => n, n => default(ClassDefinition), StringComparer.OrdinalIgnoreCase);`
`37`		`- public IEnumerable<ClassDefinition> LoadedClassDefinitions => _classDefinitions.Values;`
	`37`	`+ private readonly Dictionary<string, string> _typeMismatches = new() { ["Win32_LogicalElement"] = "CIM_LogicalElement" };`
	`38`	`+ private readonly HashSet<string> _loadedClassDefinitions = new(StringComparer.OrdinalIgnoreCase);`
`38`	`39`
`39`		`- private string? CheckClass(string? className)`
	`40`	`+ public async Task Load(IEnumerable<string> classesToLoad)`
`40`	`41`	`{`
`41`		`- if (className == null)`
	`42`	`+ foreach (var className in classesToLoad)`
`42`	`43`	`{`
`43`		`- return null;`
	`44`	`+ await TryLoadClass(className);`
`44`	`45`	`}`
`45`	`46`
`46`		`- if ("Win32_LogicalElement".Equals(className))`
	`47`	`+ channel.Complete();`
	`48`	`+ }`
	`49`	`+`
	`50`	`+ private async Task<string?> TryLoadClass(string? className)`
	`51`	`+ {`
	`52`	`+ if (className == null)`
`47`	`53`	`{`
`48`		`- return CheckClass("CIM_LogicalElement");`
	`54`	`+ return null;`
`49`	`55`	`}`
`50`	`56`
`51`		`- if (!_classDefinitions.ContainsKey(className))`
	`57`	`+ if (_typeMismatches.TryGetValue(className, out var correctClassName))`
`52`	`58`	`{`
`53`		`- if (className.IndexOf('_') == -1)`
`54`		`- {`
`55`		`- return CheckClass($"__{className}");`
`56`		`- }`
`57`		`-`
`58`		`- _classDefinitions.Add(className, default);`
`59`		`- Console.WriteLine($"Met new class {className}.");`
	`59`	`+ return await TryLoadClass(correctClassName);`
`60`	`60`	`}`
`61`		`- return className;`
`62`		`- }`
`63`	`61`
`64`		`- public async Task Load()`
`65`		`- {`
`66`		`- foreach (var className in GetUnloadedClassNames())`
	`62`	`+ if (_loadedClassDefinitions.Add(className))`
`67`	`63`	`{`
`68`	`64`	`if (await LoadClassDefinition(className) is ClassDefinition classDefinition)`
`69`	`65`	`{`
`70`		`- _classDefinitions[className] = classDefinition;`
	`66`	`+ Console.WriteLine($"Loaded info for {className}:");`
	`67`	`+ await channel.WriteAsync(classDefinition);`
	`68`	`+ return className;`
`71`	`69`	`}`
`72`		`- else`
	`70`	`+ else if (className.IndexOf('_') == -1)`
`73`	`71`	`{`
`74`		`- _classDefinitions.Remove(className);`
	`72`	`+ var prefixedClassName = $"__{className}";`
	`73`	`+ _typeMismatches[className] = prefixedClassName;`
	`74`	`+ return await TryLoadClass(prefixedClassName);`
`75`	`75`	`}`
`76`	`76`	`}`
`77`		`- }`
`78`	`77`
`79`		`- private IEnumerable<string> GetUnloadedClassNames()`
`80`		`- {`
`81`		`- var classNames = _classDefinitions.Where(kvp => kvp.Value.ClassName == null).Select(kvp => kvp.Key).ToArray();`
`82`		`- while (classNames.Length > 0)`
`83`		`- {`
`84`		`- foreach (var className in classNames)`
`85`		`- {`
`86`		`- yield return className;`
`87`		`- }`
`88`		`- classNames = _classDefinitions.Where(kvp => kvp.Value.ClassName == null).Select(kvp => kvp.Key).ToArray();`
`89`		`- }`
	`78`	`+ return null;`
`90`	`79`	`}`
`91`	`80`
`92`	`81`	`private async Task<ClassDefinition?> LoadClassDefinition(string className)`
`93`	`82`	`{`
`94`		`- Console.WriteLine($"Getting info for {className}:");`
	`83`	`+ Console.WriteLine($"Loading info for {className}:");`
`95`	`84`	`Uri? classUri = null;`
`96`	`85`	`Uri[] uris = className[0] == '_'`
`97`		`- ? [new Uri($"https://learn.microsoft.com/en-gb/windows/win32/wmisdk/{className.Replace('_', '-')}")]`
	`86`	`+ ? [new Uri($"https://learn.microsoft.com/en-us/windows/win32/wmisdk/{className.Replace('_', '-')}")]`
`98`	`87`	`: [new Uri($"https://learn.microsoft.com/en-us/windows/win32/cimwin32prov/{className.Replace('_', '-')}"),`
`99`	`88`	`new Uri($"https://learn.microsoft.com/en-us/previous-versions/windows/desktop/secrcw32prov//{className.Replace('_', '-')}")];`
`100`	`89`
`@@ -111,15 +100,14 @@ private IEnumerable<string> GetUnloadedClassNames()`
`111`	`100`	`{`
`112`	`101`	`if (i + 1 == uris.Length)`
`113`	`102`	`{`
`114`		`- ErrorReporter.Report($"Unable to find Microsoft Learn page to parse for {className}: {ex.Message}", ex);`
	`103`	`+ ErrorReporter.Report($"Unable to find Microsoft Learn page to parse for {className}: {ex.Message}", ex, throwOrBreak: false);`
`115`	`104`	`break;`
`116`	`105`	`}`
`117`	`106`	`}`
`118`	`107`	`}`
`119`	`108`
`120`	`109`	`if (classUri == null \|\| pageContents == null)`
`121`	`110`	`{`
`122`		`- ErrorReporter.Report($"Failed to load {className}.");`
`123`	`111`	`return null;`
`124`	`112`	`}`
`125`	`113`
`@@ -151,14 +139,14 @@ private IEnumerable<string> GetUnloadedClassNames()`
`151`	`139`	`ErrorReporter.Report($"Encounterd different type {classDef[1]} when parsing data for {className}.");`
`152`	`140`	`}`
`153`	`141`
`154`		`- superClass = CheckClass(classDef.Length > 2 ? classDef[^1] : null);`
	`142`	`+ superClass = await TryLoadClass(classDef.Length > 2 ? classDef[^1] : null);`
`155`	`143`
`156`	`144`	`break;`
`157`	`145`	`}`
`158`	`146`
`159`	`147`	`var propertyBlock = pageContents.IndexOf("<h3 id=\"properties\"");`
`160`	`148`	`var endBlock = pageContents.IndexOf("<h3", propertyBlock + 1);`
`161`		`- var properties = propertyBlock == -1 ? [] : ParseProperties(codeLines[(lineIndex + 2)..^1], pageContents[propertyBlock..endBlock]).ToList();`
	`149`	`+ var properties = propertyBlock == -1 ? [] : await ParseProperties(codeLines[(lineIndex + 2)..^1], pageContents[propertyBlock..endBlock]);`
`162`	`150`
`163`	`151`	`var methodBlock = pageContents.IndexOf("<h3 id=\"methods\"");`
`164`	`152`	`endBlock = pageContents.IndexOf("<h3", methodBlock + 1);`
`@@ -177,31 +165,37 @@ private static async Task<string> GetPageContentsAsync(Uri url)`
`177`	`165`	`return await response.Content.ReadAsStringAsync();`
`178`	`166`	`}`
`179`	`167`
`180`		`- private IEnumerable<PropertyDefinition> ParseProperties(string[] propertyLines, string propertiesBlock)`
	`168`	`+ private async Task<List<PropertyDefinition>> ParseProperties(string[] propertyLines, string propertiesBlock)`
`181`	`169`	`{`
`182`		`- foreach (var property in propertyLines.Select(ParsePropertyLine).OfType<PropertyDefinition>())`
	`170`	`+ var result = new List<PropertyDefinition>(propertyLines.Length);`
	`171`	`+ foreach (var propertyLine in propertyLines)`
`183`	`172`	`{`
`184`		`- if (TryGetPropertyV1(property.Name, propertiesBlock, out var propertyBlock))`
	`173`	`+ if (await ParsePropertyLine(propertyLine) is PropertyDefinition property)`
`185`	`174`	`{`
`186`		`- if (PropertyIsInherited(propertyBlock))`
	`175`	`+ if (TryGetPropertyV1(property.Name, propertiesBlock, out var propertyBlock))`
`187`	`176`	`{`
`188`		`- continue;`
	`177`	`+ if (PropertyIsInherited(propertyBlock))`
	`178`	`+ {`
	`179`	`+ continue;`
	`180`	`+ }`
	`181`	`+ result.Add(await UpdatePropertyV1(property, propertyBlock));`
`189`	`182`	`}`
`190`		`- yield return UpdatePropertyV1(property, propertyBlock);`
`191`		`- }`
`192`		`- else if (TryGetPropertyV2(property.Name, propertiesBlock, out propertyBlock))`
`193`		`- {`
`194`		`- if (PropertyIsInherited(propertyBlock))`
	`183`	`+ else if (TryGetPropertyV2(property.Name, propertiesBlock, out propertyBlock))`
`195`	`184`	`{`
`196`		`- continue;`
	`185`	`+ if (PropertyIsInherited(propertyBlock))`
	`186`	`+ {`
	`187`	`+ continue;`
	`188`	`+ }`
	`189`	`+ result.Add(await UpdatePropertyV2(property, propertyBlock));`
	`190`	`+ }`
	`191`	`+ else`
	`192`	`+ {`
	`193`	`+ ErrorReporter.Report($"No description found for property {property.Name}.", throwOrBreak: false);`
`197`	`194`	`}`
`198`		`- yield return UpdatePropertyV2(property, propertyBlock);`
`199`		`- }`
`200`		`- else`
`201`		`- {`
`202`		`- ErrorReporter.Report($"No description found for property {property.Name}.", throwOrBreak: false);`
`203`	`195`	`}`
`204`	`196`	`}`
	`197`	`+`
	`198`	`+ return result;`
`205`	`199`	`}`
`206`	`200`
`207`	`201`	`private static bool TryGetPropertyV1(string propertyName, string propertiesBlock, [MaybeNullWhen(false)]out string propertyBlock)`
`@@ -235,11 +229,12 @@ private static bool TryGetPropertyV2(string propertyName, string propertiesBlock`
`235`	`229`	`private static bool PropertyIsInherited(string propertyBlock)`
`236`	`230`	`=> propertyBlock.Contains("This property is inherited from");`
`237`	`231`
`238`		`- private PropertyDefinition UpdatePropertyV1(PropertyDefinition property, string propertyBlock)`
	`232`	`+ private async Task<PropertyDefinition> UpdatePropertyV1(PropertyDefinition property, string propertyBlock)`
`239`	`233`	`{`
`240`	`234`	`foreach (var paragraph in ParagraphRegex.Matches(propertyBlock).Select(TrimHTML))`
`241`	`235`	`{`
`242`		`- if (!ParseSubProperty(ref property, paragraph))`
	`236`	`+ (var parsed, property) = await ParseSubProperty(property, paragraph);`
	`237`	`+ if (!parsed)`
`243`	`238`	`{`
`244`	`239`	`property = property with { Description = paragraph };`
`245`	`240`	`break;`
`@@ -249,11 +244,11 @@ private PropertyDefinition UpdatePropertyV1(PropertyDefinition property, string`
`249`	`244`	`return property;`
`250`	`245`	`}`
`251`	`246`
`252`		`- private PropertyDefinition UpdatePropertyV2(PropertyDefinition property, string propertyBlock)`
	`247`	`+ private async Task<PropertyDefinition> UpdatePropertyV2(PropertyDefinition property, string propertyBlock)`
`253`	`248`	`{`
`254`	`249`	`foreach (var propertyDescription in PropertyRegex.Matches(propertyBlock).Select(TrimHTML))`
`255`	`250`	`{`
`256`		`- ParseSubProperty(ref property, propertyDescription);`
	`251`	`+ (_, property) = await ParseSubProperty(property, propertyDescription);`
`257`	`252`	`}`
`258`	`253`
`259`	`254`	`if (TrimHTML(DescriptionRegex.Match(propertyBlock)) is string description && description.Length > 0)`
`@@ -264,12 +259,12 @@ private PropertyDefinition UpdatePropertyV2(PropertyDefinition property, string`
`264`	`259`	`return property;`
`265`	`260`	`}`
`266`	`261`
`267`		`- private bool ParseSubProperty(ref PropertyDefinition property, string paragraph)`
	`262`	`+ private async Task<(bool, PropertyDefinition)> ParseSubProperty(PropertyDefinition property, string paragraph)`
`268`	`263`	`{`
`269`	`264`	`var colonIndex = paragraph.IndexOf(':');`
`270`	`265`	`if (colonIndex == -1)`
`271`	`266`	`{`
`272`		`- return false;`
	`267`	`+ return (false, property);`
`273`	`268`	`}`
`274`	`269`
`275`	`270`	`switch (paragraph[..colonIndex])`
`@@ -289,7 +284,7 @@ private bool ParseSubProperty(ref PropertyDefinition property, string paragraph)`
`289`	`284`	`}`
`290`	`285`	`else if (typeName.Contains('_'))`
`291`	`286`	`{`
`292`		`- property = property with { Type = CimType.Reference, ReferencedClass = CheckClass(typeName) };`
	`287`	`+ property = property with { Type = CimType.Reference, ReferencedClass = await TryLoadClass(typeName) };`
`293`	`288`	`}`
`294`	`289`	`else`
`295`	`290`	`{`
`@@ -314,7 +309,7 @@ private bool ParseSubProperty(ref PropertyDefinition property, string paragraph)`
`314`	`309`	`property = property with { Qualifiers = ParseQualifiers(paragraph[(colonIndex + 2)..]) };`
`315`	`310`	`break;`
`316`	`311`	`}`
`317`		`- return true;`
	`312`	`+ return (true, property);`
`318`	`313`	`}`
`319`	`314`
`320`	`315`	`private static List<QualifierDefinition> ParseQualifiers(string qualifiers)`
`@@ -334,7 +329,7 @@ private static string TrimHTML(string source)`
`334`	`329`	`.Replace(" ", " ")`
`335`	`330`	`.Trim();`
`336`	`331`
`337`		`- private PropertyDefinition? ParsePropertyLine(string propertyLine)`
	`332`	`+ private async Task<PropertyDefinition?> ParsePropertyLine(string propertyLine)`
`338`	`333`	`{`
`339`	`334`	`var parts = TrimHTML(propertyLine).Split(' ', options: StringSplitOptions.RemoveEmptyEntries);`
`340`	`335`
`@@ -347,7 +342,7 @@ private static string TrimHTML(string source)`
`347`	`342`	`if (!Enum.TryParse(parts[0], ignoreCase: true, out CimType type) && parts[0].Contains('_'))`
`348`	`343`	`{`
`349`	`344`	`type = CimType.Reference;`
`350`		`- referenceType = CheckClass(parts[0]);`
	`345`	`+ referenceType = await TryLoadClass(parts[0]);`
`351`	`346`	`}`
`352`	`347`
`353`	`348`	`var name = parts[^2][0] == '=' ? parts[^3] : parts[^1];`