diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index defc9f9..060a4e1 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -2,13 +2,14 @@
   <PropertyGroup>
     <!-- Common Settings -->
     <Nullable>enable</Nullable>
-    <LangVersion>10</LangVersion>
+    <LangVersion>12</LangVersion>
     <RootNamespace>SGF</RootNamespace>
     <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
     <SGFSourceDir>$(MSBuildThisFileDirectory)</SGFSourceDir>
     <LibsDir>$(SGFSourceDir)libs\</LibsDir>
     <ImgDir>$(MSBuildThisFileDirectory)..\img\</ImgDir>
     <SGfIco>$(MSBuildThisFileDirectory)..\img\icon.png</SGfIco>
+    <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
     <!-- Icons -->
     <ApplicationIcon>$(MSBuildThisFileDirectory)..\img\icon.ico</ApplicationIcon>
 
diff --git a/src/SourceGenerator.Foundations.Tests/BaseTest.cs b/src/SourceGenerator.Foundations.Tests/BaseTest.cs
deleted file mode 100644
index 5f49f53..0000000
--- a/src/SourceGenerator.Foundations.Tests/BaseTest.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-using Microsoft.CodeAnalysis.CSharp;
-using System.Reflection;
-using Xunit.Abstractions;
-
-namespace SourceGenerator.Foundations.Tests
-{
-    public class BaseTest
-    {
-        /// <summary>
-        /// Gets the name of the currently running test method 
-        /// </summary>
-        public string TestMethodName { get; }
-
-        protected BaseTest(ITestOutputHelper outputHelper)
-        {
-            TestMethodName = "Unknown";
-            Type type = outputHelper.GetType();
-            FieldInfo? testField = type.GetField("test", BindingFlags.Instance | BindingFlags.NonPublic);
-            ITest? test = testField?.GetValue(outputHelper) as ITest;
-            if (test != null)
-            {
-                TestMethodName = test.TestCase.TestMethod.ToString()!;
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/SourceGenerator.Foundations.Tests/CompiliationTestBase.cs b/src/SourceGenerator.Foundations.Tests/CompiliationTestBase.cs
new file mode 100644
index 0000000..f3fd231
--- /dev/null
+++ b/src/SourceGenerator.Foundations.Tests/CompiliationTestBase.cs
@@ -0,0 +1,155 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+using System.Collections.Immutable;
+using System.Reflection;
+using System.Text;
+using Xunit.Abstractions;
+
+namespace SGF
+{
+    /// <summary>
+    /// There is an attribute called `ExtendedAnalyzerRules` which are applied to source generators. Since
+    /// SGF injects code into their projects we want to make sure we don't add warnings or errors.
+    /// </summary>
+    public class CompiliationTestBase
+    {
+        public SgfAnalyzerConfigOptions AnalyzerOptions { get; }
+
+        /// <summary>
+        /// Gets the name of the currently running test method 
+        /// </summary>
+        public string TestMethodName { get; }
+
+        private readonly List<MetadataReference> m_references;
+        private readonly List<DiagnosticAnalyzer> m_analyzers;
+        protected readonly List<IIncrementalGenerator> m_incrementalGenerators;
+
+        protected CompiliationTestBase(ITestOutputHelper outputHelper)
+        {
+            m_analyzers = new List<DiagnosticAnalyzer>();
+            m_references = new List<MetadataReference>();
+            m_incrementalGenerators = new List<IIncrementalGenerator>();
+
+            AnalyzerOptions = new SgfAnalyzerConfigOptions();
+            TestMethodName = "Unkonwn";
+            Type type = outputHelper.GetType();
+            FieldInfo? testField = type.GetField("test", BindingFlags.Instance | BindingFlags.NonPublic);
+            ITest? test = testField?.GetValue(outputHelper) as ITest;
+            if (test != null)
+            {
+                TestMethodName = test.TestCase.TestMethod.ToString()!;
+            }
+
+            AddAssemblyReference("System.Runtime");
+            AddAssemblyReference("netstandard");
+            AddAssemblyReference("System.Console");
+            AddAssemblyReference("Microsoft.CodeAnalysis");
+            AddAssemblyReference("System.Linq");
+            AddMetadataReference<object>();
+            AddMetadataReference<SgfGeneratorAttribute>();
+        }
+
+
+
+        protected async Task ComposeAsync(
+            string[]? source = null,
+            Action<ImmutableArray<Diagnostic>>[]? assertDiagnostics = null,
+            Action<Compilation>[]? assertCompilation = null)
+        {
+
+            source ??= [];
+
+            CSharpCompilationOptions compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
+
+            CompilationWithAnalyzersOptions analyzerOptions = new CompilationWithAnalyzersOptions(
+                new AnalyzerOptions([], new SgfAnalyzerConfigOptionsProvider(AnalyzerOptions)),
+                null, true, false);
+
+            // Create a Roslyn compilation for the syntax tree.
+            Compilation compilation = CSharpCompilation.Create(TestMethodName)
+                .AddSyntaxTrees(source.Select(t => ParseSyntaxTree(t)).ToArray())
+                .WithOptions(compilationOptions)
+                .AddReferences(m_references);
+
+            // Create an instance of our EnumGenerator incremental source generator
+            HoistSourceGenerator generator = new HoistSourceGenerator();
+
+            // The GeneratorDriver is used to run our generator against a compilation
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(generator);
+
+            // Run the source generator!
+            driver = driver.RunGenerators(compilation)
+                .RunGeneratorsAndUpdateCompilation(compilation, out compilation, out var _);
+
+            CompilationWithAnalyzers analysis = compilation.WithAnalyzers([.. m_analyzers], analyzerOptions);
+
+            ImmutableArray<Diagnostic> diagnostics = await analysis.GetAllDiagnosticsAsync();
+            if (assertDiagnostics is not null)
+            {
+                foreach (Action<ImmutableArray<Diagnostic>> assert in assertDiagnostics)
+                {
+                    assert(diagnostics);
+                }
+            }
+
+            if (assertCompilation is not null)
+            {
+                foreach (Action<Compilation> assert in assertCompilation)
+                {
+                    assert(compilation);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Adds a new <see cref="DiagnosticAnalyzer"/> that will be eveluated during compliation.
+        /// </summary>
+        protected void AddAnalyzer<T>() where T : DiagnosticAnalyzer, new()
+            => m_analyzers.Add(new T());
+
+        /// <summary>
+        /// Adds a new <see cref="DiagnosticAnalyzer"/> that will be eveluated during compliation.
+        /// </summary>
+        protected void AddAnalyzer<T>(T instance) where T : DiagnosticAnalyzer
+            => m_analyzers.Add(instance);
+
+        /// <summary>
+        /// Adds a new <see cref="IIncrementalGenerator"/> that will be executed during compliation.
+        /// </summary>
+        protected void AddGenerator<T>() where T : IIncrementalGenerator, new()
+            => m_incrementalGenerators.Add(new T());
+
+        /// <summary>
+        /// Adds a new <see cref="IIncrementalGenerator"/> that will be executed during compliation.
+        /// </summary>
+        protected void AddGenerator<T>(T instance) where T : IIncrementalGenerator
+            => m_incrementalGenerators.Add(instance);
+
+        /// <summary>
+        /// Adds a new <see cref="MetadataReference"/> for the given assembly that the type belongs in
+        /// </summary>
+        protected void AddMetadataReference<T>()
+            => m_references.Add(MetadataReference.CreateFromFile(typeof(T).Assembly.Location));
+
+        protected void AddAssemblyReference(string assemblyName)
+        {
+#pragma warning disable RS1035 // Do not use APIs banned for analyzers
+            Assembly assembly = Assembly.Load(assemblyName);
+            if (assembly is not null)
+            {
+                m_references.Add(MetadataReference.CreateFromFile(assembly.Location));
+            }
+#pragma warning restore RS1035 // Do not use APIs banned for analyzers
+        }
+
+        protected static SyntaxTree ParseSyntaxTree(string source, string fileName = "TestClass.cs")
+        {
+            SourceText sourceText = SourceText.From(source, Encoding.UTF8);
+            CSharpParseOptions parseOptions = new CSharpParseOptions(LanguageVersion.CSharp12);
+            SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(source, path: fileName);
+            return syntaxTree;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/SourceGenerator.Foundations.Tests/DiagnosticAsserts.cs b/src/SourceGenerator.Foundations.Tests/DiagnosticAsserts.cs
new file mode 100644
index 0000000..16893de
--- /dev/null
+++ b/src/SourceGenerator.Foundations.Tests/DiagnosticAsserts.cs
@@ -0,0 +1,46 @@
+using Microsoft.CodeAnalysis;
+using System.Collections.Immutable;
+using System.Text;
+
+namespace SourceGenerator.Foundations.Tests
+{
+    /// <summary>
+    /// Contains asserts for checking if diagnostics match expected values.
+    /// </summary>
+    internal static class DiagnosticAsserts
+    {
+        public static Action<ImmutableArray<Diagnostic>> NoErrors()
+            => NoneOfSeverity(DiagnosticSeverity.Error);
+
+        public static Action<ImmutableArray<Diagnostic>> NoErrorsOrWarnings()
+            => NoneOfSeverity(DiagnosticSeverity.Warning, DiagnosticSeverity.Error);
+
+        public static Action<ImmutableArray<Diagnostic>> NoneOfSeverity(params DiagnosticSeverity[] severity)
+        {
+            HashSet<DiagnosticSeverity> set = new HashSet<DiagnosticSeverity>(severity);
+
+            return diagnostics =>
+            {
+                List<Diagnostic> filtered = diagnostics
+                    .Where(d => set.Contains(d.Severity))
+                    .ToList();
+
+                if(filtered.Count > 0)
+                {
+                    StringBuilder errorBuilder = new StringBuilder();
+
+                    foreach(var dia in filtered)
+                    {
+                        Location location = dia.Location;
+                        string? filePath = Path.GetFileName(location.SourceTree?.FilePath);
+
+                        string error = $"{filePath} {location.SourceSpan.Start} {dia.Severity} {dia.Descriptor.Id}: {dia.GetMessage()}";
+
+                        errorBuilder.AppendLine(error);
+                    }
+                    Assert.Fail(errorBuilder.ToString());
+                }
+            };
+        }
+    }
+}
diff --git a/src/SourceGenerator.Foundations.Tests/ExtendedAnalyzerRuleTests.cs b/src/SourceGenerator.Foundations.Tests/ExtendedAnalyzerRuleTests.cs
new file mode 100644
index 0000000..7ee16da
--- /dev/null
+++ b/src/SourceGenerator.Foundations.Tests/ExtendedAnalyzerRuleTests.cs
@@ -0,0 +1,48 @@
+using Microsoft.CodeAnalysis.CSharp.Analyzers;
+using SGF;
+using Xunit.Abstractions;
+
+namespace SourceGenerator.Foundations.Tests
+{
+    /// <summary>
+    /// Runs Roslyns analyzers to validate that code that was added
+    /// by the <see cref="HoistSourceGenerator"/> does not cause 
+    /// errors due to `EnforceExtendedAnalyzerRules`
+    /// </summary>
+    public class ExtendedAnalyzerRuleTests : CompiliationTestBase
+    {
+        public ExtendedAnalyzerRuleTests(ITestOutputHelper outputHelper) : base(outputHelper)
+        {
+            AnalyzerOptions.EnforceExtendedAnalyzerRules = true;
+
+            AddGenerator<HoistSourceGenerator>();
+            AddAnalyzer<CSharpSymbolIsBannedInAnalyzersAnalyzer>();
+        }
+
+        [Fact]
+        public Task No_Banned_Apis_In_Source()
+        {
+            string source = """
+                using SGF;
+
+                namespace Yellow
+                {
+                    [SgfGenerator]
+                    public class CustomGenerator : IncrementalGenerator
+                    {
+                        public CustomGenerator() : base("Generator")
+                        {}
+
+                        public override void OnInitialize(SgfInitializationContext context)
+                        {}
+                    }
+                }
+                """;
+
+            return ComposeAsync([source],
+                assertDiagnostics: [
+                    DiagnosticAsserts.NoErrors()
+                ]);
+        }
+    }
+}
diff --git a/src/SourceGenerator.Foundations.Tests/GeneratorTest.cs b/src/SourceGenerator.Foundations.Tests/GeneratorTest.cs
deleted file mode 100644
index a157f09..0000000
--- a/src/SourceGenerator.Foundations.Tests/GeneratorTest.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using SourceGenerator.Foundations.Tests.Results;
-using Xunit.Abstractions;
-
-namespace SourceGenerator.Foundations.Tests
-{
-
-    public abstract class GeneratorTest : BaseTest
-    {
-  
-
-        protected GeneratorTest(ITestOutputHelper outputHelper) : base(outputHelper)
-        {
-        }
-
-
-
-        protected void Compose<T>(string source,
-            params Action<ITreeAssert>[] treeAsserts) where T : IIncrementalGenerator, new()
-        {
-            SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(source);
-
-            CSharpCompilation compilation = CSharpCompilation.Create(
-                assemblyName: $"{TestMethodName}",
-                syntaxTrees: new[] { syntaxTree });
-
-            T incrementalGenerator = new();
-
-            GeneratorDriver driver = CSharpGeneratorDriver.Create(incrementalGenerator);
-
-            driver = driver.RunGenerators(compilation);
-
-
-            GeneratorDriverRunResult result = driver.GetRunResult();
-            GeneratorDriverRunAssert assertResult = new GeneratorDriverRunAssert(result);
-
-            foreach(Action<ITreeAssert> assert in treeAsserts)
-            {
-                assert(assertResult);
-            }
-
-        }
-    }
-}
diff --git a/src/SourceGenerator.Foundations.Tests/SgfAnalyzerConfigOptions.cs b/src/SourceGenerator.Foundations.Tests/SgfAnalyzerConfigOptions.cs
new file mode 100644
index 0000000..47651ca
--- /dev/null
+++ b/src/SourceGenerator.Foundations.Tests/SgfAnalyzerConfigOptions.cs
@@ -0,0 +1,40 @@
+using Microsoft.CodeAnalysis.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+
+namespace SGF
+{
+
+    public class SgfAnalyzerConfigOptions : AnalyzerConfigOptions
+    {
+        private const string BUILD_PROP_EXTENDED_RULES = "build_property.EnforceExtendedAnalyzerRules";
+
+        private readonly Dictionary<string, string?> m_values;
+
+        public bool EnforceExtendedAnalyzerRules
+        {
+            get => m_values.TryGetValue(BUILD_PROP_EXTENDED_RULES, out string? rawValue) &&
+                bool.TryParse(rawValue, out bool parsedValue) &&
+                parsedValue;
+            set => m_values[BUILD_PROP_EXTENDED_RULES] = value
+                ? "true" // has to be lower 
+                : "false";
+        }
+
+        public SgfAnalyzerConfigOptions()
+        {
+            m_values = new Dictionary<string, string?>();
+
+            EnforceExtendedAnalyzerRules = false;
+        }
+
+        public override bool TryGetValue(string key, [NotNullWhen(true)] out string? value)
+        {
+            if (m_values.TryGetValue(key, out value))
+            {
+                value ??= "";
+                return true;
+            }
+            return false;
+        }
+    }
+}
diff --git a/src/SourceGenerator.Foundations.Tests/SgfAnalyzerConfigOptionsProvider.cs b/src/SourceGenerator.Foundations.Tests/SgfAnalyzerConfigOptionsProvider.cs
new file mode 100644
index 0000000..cbf4fae
--- /dev/null
+++ b/src/SourceGenerator.Foundations.Tests/SgfAnalyzerConfigOptionsProvider.cs
@@ -0,0 +1,27 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace SGF
+{
+    public class SgfAnalyzerConfigOptionsProvider : AnalyzerConfigOptionsProvider
+    {
+        public SgfAnalyzerConfigOptions SharedOptions { get; }
+        public override AnalyzerConfigOptions GlobalOptions => SharedOptions;
+
+        public SgfAnalyzerConfigOptionsProvider()
+        {
+            SharedOptions = new SgfAnalyzerConfigOptions();
+        }
+
+        public SgfAnalyzerConfigOptionsProvider(SgfAnalyzerConfigOptions options)
+        {
+            SharedOptions = options;
+        }
+
+        public override AnalyzerConfigOptions GetOptions(SyntaxTree tree)
+            => GlobalOptions;
+
+        public override AnalyzerConfigOptions GetOptions(AdditionalText textFile)
+            => GlobalOptions;
+    }
+}
diff --git a/src/SourceGenerator.Foundations.Tests/SourceGenerator.Foundations.Tests.csproj b/src/SourceGenerator.Foundations.Tests/SourceGenerator.Foundations.Tests.csproj
index d4f83a1..0d549d2 100644
--- a/src/SourceGenerator.Foundations.Tests/SourceGenerator.Foundations.Tests.csproj
+++ b/src/SourceGenerator.Foundations.Tests/SourceGenerator.Foundations.Tests.csproj
@@ -1,15 +1,17 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net6.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
+    <LangVersion>12</LangVersion>
     <Nullable>enable</Nullable>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.3.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.11.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="4.11.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
     <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
@@ -20,11 +22,19 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
+
+    <!-- ==== Referencing Analyzers ====
+      Normally you never actually reference the analyzer they just get used by the compiler internally.
+      When adding a NuGet reference it just does that behind the scenes. For these unit tests I needed
+      to reference the type, so that is this weird workaround of using the path and navigating to the dll
+    -->
+    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.11.0" GeneratePathProperty="true" />
+    <Reference Include="$(PkgMicrosoft_CodeAnalysis_Analyzers)\analyzers\dotnet\cs\Microsoft.CodeAnalysis.CSharp.Analyzers.dll" />
+    <Reference Include="$(PkgMicrosoft_CodeAnalysis_Analyzers)\analyzers\dotnet\cs\Microsoft.CodeAnalysis.Analyzers.dll" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\SourceGenerator.Foundations.Contracts\SourceGenerator.Foundations.Contracts.csproj" />
     <ProjectReference Include="..\SourceGenerator.Foundations\SourceGenerator.Foundations.csproj" />
   </ItemGroup>
-
 </Project>
diff --git a/src/SourceGenerator.Foundations/Templates/SourceGeneratorHoistBase.cs b/src/SourceGenerator.Foundations/Templates/SourceGeneratorHoistBase.cs
index 1a637db..4e4934c 100644
--- a/src/SourceGenerator.Foundations/Templates/SourceGeneratorHoistBase.cs
+++ b/src/SourceGenerator.Foundations/Templates/SourceGeneratorHoistBase.cs
@@ -115,7 +115,8 @@ private static void AddAssembly(Assembly assembly)
 
             foreach (string resource in resources)
             {
-                Console.WriteLine($"Extracting {resource} assembly from {assemblyName.Name}'s resources.");
+
+                System.Console.WriteLine($"Extracting {resource} assembly from {assemblyName.Name}'s resources.");
                 if (TryExtractingAssembly(assembly, resource, out Assembly? loadedAssembly))
                 {
                     AddAssembly(loadedAssembly!);
diff --git a/src/SourceGenerator.Foundations/msbuild.binlog b/src/SourceGenerator.Foundations/msbuild.binlog
new file mode 100644
index 0000000..c3879eb
Binary files /dev/null and b/src/SourceGenerator.Foundations/msbuild.binlog differ