[packages,C] Fixes #181. POTENTIALLY BREAKING CHANGE. Clarified the use of the 'public' utility functions in the C package. The CompilePubliclyAndLinkAgainst function has moved from C.ConsoleApplication to C.DynamicLibrary and C.Cxx.DynamicLibrary to enforce that 'public' inheritance of patches to dependents are not necessary for executables, but are for dynamic libraries. Added LinkPubliclyAgainst to C.DynamicLibrary and C.Cxx.DynamicLibrary. Added Bam.Core.Module.UsePublicPatchesPrivately, which takes the public patches from a dependent, but only applies them to the build of the current module, rather than forwarding them to any future dependees. Added more documentation to Bam.Core.Module regarding the application of patches. The likely changes to make to existing build scripts is to change CompilePubliclyAndLinkAgainst to CompileAndLinkAgainst in C.ConsoleApplication to C.GuiApplication (particularly for WindowsSDK), or that modules were previously compiling because patches had been leaked through prior to this change.

markfinal · markfinal · commit 9477f52a993e · 2016-03-25T12:51:50.000Z
diff --git a/Bam.Core/Module.cs b/Bam.Core/Module.cs
@@ -368,15 +368,29 @@ public void
         }
 
         /// <summary>
-        /// Instruct a module to use the public patches from module.
+        /// Instruct this module to use the public patches, and any inherited patches, from the dependent module.
+        /// All inherited patches will be forwarded onto any uses of this module.
         /// </summary>
-        /// <param name="module">Module.</param>
+        /// <param name="module">Dependent module containing patches to use.</param>
         public void
         UsePublicPatches(
             Module module)
         {
-            this.ExternalPatches.Add(module.PublicPatches);
-            this.ExternalPatches.AddRange(module.ExternalPatches);
+            this.PublicInheritedPatches.Add(module.PublicPatches);
+            this.PublicInheritedPatches.AddRange(module.PublicInheritedPatches);
+        }
+
+        /// <summary>
+        /// Instruct this module to use the public patches from the dependent module.
+        /// All patches will be used privately to this module.
+        /// </summary>
+        /// <param name="module">Dependent module containing patches to use.</param>
+        public void
+        UsePublicPatchesPrivately(
+            Module module)
+        {
+            this.PrivateInheritedPatches.Add(module.PublicPatches);
+            this.PrivateInheritedPatches.AddRange(module.PublicInheritedPatches);
         }
 
         /// <summary>
@@ -389,7 +403,7 @@ public bool HasPatches
             {
                 return (this.PrivatePatches.Count() > 0) ||
                        (this.PublicPatches.Count() > 0) ||
-                       (this.ExternalPatches.Count() > 0);
+                       (this.PublicInheritedPatches.Count() > 0);
             }
         }
 
@@ -461,7 +475,8 @@ public System.Collections.ObjectModel.ReadOnlyCollection<Module> Children
 
         private System.Collections.Generic.List<PrivatePatchDelegate> PrivatePatches = new System.Collections.Generic.List<PrivatePatchDelegate>();
         private System.Collections.Generic.List<PublicPatchDelegate> PublicPatches = new System.Collections.Generic.List<PublicPatchDelegate>();
-        private System.Collections.Generic.List<System.Collections.Generic.List<PublicPatchDelegate>> ExternalPatches = new System.Collections.Generic.List<System.Collections.Generic.List<PublicPatchDelegate>>();
+        private System.Collections.Generic.List<System.Collections.Generic.List<PublicPatchDelegate>> PublicInheritedPatches = new System.Collections.Generic.List<System.Collections.Generic.List<PublicPatchDelegate>>();
+        private System.Collections.Generic.List<System.Collections.Generic.List<PublicPatchDelegate>> PrivateInheritedPatches = new System.Collections.Generic.List<System.Collections.Generic.List<PublicPatchDelegate>>();
 
         /// <summary>
         /// Get the dictionary of keys and strings for all registered generated paths with the module.
@@ -584,9 +599,19 @@ public void
 
         /// <summary>
         /// Apply any patches set on the module with the settings for its tool.
-        /// </summary>
-        /// <param name="settings">Settings.</param>
-        /// <param name="honourParents">If set to <c>true</c> honour parents takes private patches from any parent module
+        /// Order of evaluation is:
+        /// 1. If this is a child module, and honourParents is true, apply private patches from the parent.
+        /// 2. Apply private patches of this.
+        /// 3. Apply inherited private patches of this.
+        /// 4. If this is a child module, and honourParents is true, apply public patches from the parent.
+        /// 5. Apply public patches of this.
+        /// 6. If this is a child module, and honourParents is true, apply any inherited patches from the parent.
+        /// 7. Apply inherited public patches of this.
+        /// Inherited patches are the mechanism for transient dependencies, where dependencies filter up the module hierarchy.
+        /// See UsePublicPatches and UsePublicPatchesPrivately.
+        /// </summary>
+        /// <param name="settings">Settings object to apply patches to.</param>
+        /// <param name="honourParents">If set to <c>true</c>, honourParents takes patches from any parent module
         /// and also invokes those if this module is a child.</param>
         public void
         ApplySettingsPatches(
@@ -611,6 +636,13 @@ public void
             {
                 patch(settings);
             }
+            foreach (var patchList in this.PrivateInheritedPatches)
+            {
+                foreach (var patch in patchList)
+                {
+                    patch(settings, this);
+                }
+            }
             if (parentModule != null)
             {
                 foreach (var patch in parentModule.PublicPatches)
@@ -624,15 +656,15 @@ public void
             }
             if (parentModule != null)
             {
-                foreach (var patchList in parentModule.ExternalPatches)
+                foreach (var patchList in parentModule.PublicInheritedPatches)
                 {
                     foreach (var patch in patchList)
                     {
                         patch(settings, this);
                     }
                 }
             }
-            foreach (var patchList in this.ExternalPatches)
+            foreach (var patchList in this.PublicInheritedPatches)
             {
                 foreach (var patch in patchList)
                 {
diff --git a/Changelog.txt b/Changelog.txt
@@ -1,3 +1,5 @@
+25-Mar-2016 Fixes #181. POTENTIALLY BREAKING CHANGE. Clarified the use of the 'public' utility functions in the C package. The CompilePubliclyAndLinkAgainst function has moved from C.ConsoleApplication to C.DynamicLibrary and C.Cxx.DynamicLibrary to enforce that 'public' inheritance of patches to dependents are not necessary for executables, but are for dynamic libraries. Added LinkPubliclyAgainst to C.DynamicLibrary and C.Cxx.DynamicLibrary. Added Bam.Core.Module.UsePublicPatchesPrivately, which takes the public patches from a dependent, but only applies them to the build of the current module, rather than forwarding them to any future dependees. Added more documentation to Bam.Core.Module regarding the application of patches. The likely changes to make to existing build scripts is to change CompilePubliclyAndLinkAgainst to CompileAndLinkAgainst in C.ConsoleApplication to C.GuiApplication (particularly for WindowsSDK), or that modules were previously compiling because patches had been leaked through prior to this change.
+
 25-Mar-2016 Fixes #182. When the C# assembly for all the packages in a build fails to compile, an improved error message is now displayed, hinting at using the command line option in bam for enabling debug symbols, and the option to generate a debuggable project in one of the applicable IDEs (VisualStudio/Xamarin Studio/MonoDevelop).
 
 25-Mar-2016 Fixes #180. C.DynamicLibrary and C.Cxx.DynamicLibrary that identify dynamic library dependencies with CompilePubliclyAndLinkAgainst now forward those dependencies on, just like how StaticLibraries already do. If the public API in dynamic library D is exposed in the public API of dynamic library E, then it is legal for a compilation step dependent on D to invoke calls in E that were not resolved during D's link. This change simplifies writing build scripts in that transient dynamic dependencies no longer need to be manually specified.
diff --git a/packages/C/bam/Scripts/ConsoleApplication.cs b/packages/C/bam/Scripts/ConsoleApplication.cs
@@ -37,7 +37,7 @@ public class ConsoleApplication :
         CModule
     {
         protected Bam.Core.Array<Bam.Core.Module> sourceModules = new Bam.Core.Array<Bam.Core.Module>();
-        private Bam.Core.Array<Bam.Core.Module> linkedModules = new Bam.Core.Array<Bam.Core.Module>();
+        protected Bam.Core.Array<Bam.Core.Module> linkedModules = new Bam.Core.Array<Bam.Core.Module>();
         private ILinkingPolicy Policy = null;
 
         static public Bam.Core.PathKey Key = Bam.Core.PathKey.Generate("ExecutableFile");
@@ -159,6 +159,7 @@ public void
 
         /// <summary>
         /// Application is linked against the DependentModule type.
+        /// Any public patches of DependentModule are applied privately to the Application.
         /// </summary>
         /// <typeparam name="DependentModule">The 1st type parameter.</typeparam>
         public void
@@ -167,7 +168,7 @@ public void
             var dependent = Bam.Core.Graph.Instance.FindReferencedModule<DependentModule>();
             this.DependsOn(dependent);
             this.linkedModules.Add(dependent);
-            this.UsePublicPatches(dependent);
+            this.UsePublicPatchesPrivately(dependent);
         }
 
         /// <summary>
@@ -225,23 +226,7 @@ public void
                 source.UsePublicPatches(dependent);
             }
             this.LinkAllForwardedDependenciesFromLibraries(dependent);
-        }
-
-        /// <summary>
-        /// Specified sources and the application compiles and links against the DependentModule, and the
-        /// application uses patches from the dependent.
-        /// </summary>
-        /// <param name="affectedSource">Required source module.</param>
-        /// <param name="affectedSources">Optional list of additional sources.</param>
-        /// <typeparam name="DependentModule">The 1st type parameter.</typeparam>
-        public virtual void
-        CompilePubliclyAndLinkAgainst<DependentModule>(
-            CModule affectedSource,
-            params CModule[] additionalSources) where DependentModule : CModule, new()
-        {
-            this.CompileAndLinkAgainst<DependentModule>(affectedSource, additionalSources);
-            var dependent = Bam.Core.Graph.Instance.FindReferencedModule<DependentModule>();
-            this.UsePublicPatches(dependent);
+            this.UsePublicPatchesPrivately(dependent);
         }
 
         private void
diff --git a/packages/C/bam/Scripts/CxxDynamicLibrary.cs b/packages/C/bam/Scripts/CxxDynamicLibrary.cs
@@ -159,17 +159,40 @@ public void
             this.UsePublicPatches(dependent);
         }
 
-        public override void
+        /// <summary>
+        /// Specified sources and the application compiles and links against the DependentModule, and the
+        /// application uses patches from the dependent.
+        /// </summary>
+        /// <param name="affectedSource">Required source module.</param>
+        /// <param name="affectedSources">Optional list of additional sources.</param>
+        /// <typeparam name="DependentModule">The 1st type parameter.</typeparam>
+        public void
         CompilePubliclyAndLinkAgainst<DependentModule>(
             CModule affectedSource,
-            params CModule[] additionalSources)
+            params CModule[] additionalSources) where DependentModule : CModule, new()
         {
             var dependent = Bam.Core.Graph.Instance.FindReferencedModule<DependentModule>();
             if (dependent is C.DynamicLibrary || dependent is C.Cxx.DynamicLibrary)
             {
                 this.forwardedDeps.AddUnique(dependent);
             }
-            base.CompilePubliclyAndLinkAgainst<DependentModule>(affectedSource, additionalSources);
+            this.CompileAndLinkAgainst<DependentModule>(affectedSource, additionalSources);
+            this.UsePublicPatches(dependent);
+        }
+
+        /// <summary>
+        /// DynamicLibrary is linked against the DependentModule type.
+        /// Any public patches of DependentModule are applied publicly to the DynamicLibrary, and will be inherited
+        /// by any module depending on the DynamicLibrary.
+        /// </summary>
+        /// <typeparam name="DependentModule">The 1st type parameter.</typeparam>
+        public void
+        LinkPubliclyAgainst<DependentModule>() where DependentModule : CModule, new()
+        {
+            var dependent = Bam.Core.Graph.Instance.FindReferencedModule<DependentModule>();
+            this.DependsOn(dependent);
+            this.linkedModules.Add(dependent);
+            this.UsePublicPatches(dependent);
         }
 
         protected sealed override void
diff --git a/packages/C/bam/Scripts/DynamicLibrary.cs b/packages/C/bam/Scripts/DynamicLibrary.cs
@@ -132,21 +132,44 @@ public void
                     continue;
                 }
                 source.UsePublicPatches(dependent);
-                this.UsePublicPatches(dependent);
             }
+            this.UsePublicPatches(dependent);
         }
 
-        public override void
+        /// <summary>
+        /// Specified sources and the application compiles and links against the DependentModule, and the
+        /// application uses patches from the dependent.
+        /// </summary>
+        /// <param name="affectedSource">Required source module.</param>
+        /// <param name="affectedSources">Optional list of additional sources.</param>
+        /// <typeparam name="DependentModule">The 1st type parameter.</typeparam>
+        public void
         CompilePubliclyAndLinkAgainst<DependentModule>(
             CModule affectedSource,
-            params CModule[] additionalSources)
+            params CModule[] additionalSources) where DependentModule : CModule, new()
         {
             var dependent = Bam.Core.Graph.Instance.FindReferencedModule<DependentModule>();
             if (dependent is C.DynamicLibrary || dependent is C.Cxx.DynamicLibrary)
             {
                 this.forwardedDeps.AddUnique(dependent);
             }
-            base.CompilePubliclyAndLinkAgainst<DependentModule>(affectedSource, additionalSources);
+            this.CompileAndLinkAgainst<DependentModule>(affectedSource, additionalSources);
+            this.UsePublicPatches(dependent);
+        }
+
+        /// <summary>
+        /// DynamicLibrary is linked against the DependentModule type.
+        /// Any public patches of DependentModule are applied publicly to the DynamicLibrary, and will be inherited
+        /// by any module depending on the DynamicLibrary.
+        /// </summary>
+        /// <typeparam name="DependentModule">The 1st type parameter.</typeparam>
+        public void
+        LinkPubliclyAgainst<DependentModule>() where DependentModule : CModule, new()
+        {
+            var dependent = Bam.Core.Graph.Instance.FindReferencedModule<DependentModule>();
+            this.DependsOn(dependent);
+            this.linkedModules.Add(dependent);
+            this.UsePublicPatches(dependent);
         }
 
         protected sealed override void
diff --git a/packages/C/bam/Scripts/HeaderLibrary.cs b/packages/C/bam/Scripts/HeaderLibrary.cs
@@ -82,6 +82,11 @@ protected override void
             }
         }
 
+        /// <summary>
+        /// Compile against DependentModule.
+        /// As this is a header only library, this dependency implies a public inheritence of DependentModule's public patches.
+        /// </summary>
+        /// <typeparam name="DependentModule">1st generic type</typeparam>
         public void
         CompileAgainst<DependentModule>() where DependentModule : CModule, new()
         {
diff --git a/packages/VisualCCommon/bam/Scripts/Compiler.cs b/packages/VisualCCommon/bam/Scripts/Compiler.cs
@@ -58,7 +58,7 @@ protected CompilerBase()
             if (meta.UseWindowsSDKPublicPatches)
             {
                 var windowsSDK = Bam.Core.Graph.Instance.FindReferencedModule<WindowsSDK.WindowsSDK>();
-                this.UsePublicPatches(windowsSDK);
+                this.UsePublicPatchesPrivately(windowsSDK);
             }
         }
 
diff --git a/tests/InstallerTest1/bam/Scripts/Executable.cs b/tests/InstallerTest1/bam/Scripts/Executable.cs
@@ -44,10 +44,9 @@ protected override void
             this.CompileAndLinkAgainst<CStaticLibrary>(source);
             this.CompileAndLinkAgainst<CDynamicLibrary>(source);
 
-            if (this.BuildEnvironment.Platform.Includes(EPlatform.Windows) &&
-                this.Linker is VisualCCommon.LinkerBase)
+            if (this.Linker is VisualCCommon.LinkerBase)
             {
-                this.LinkAgainst<WindowsSDK.WindowsSDK>();
+                this.CompileAndLinkAgainst<WindowsSDK.WindowsSDK>(source);
             }
 
             this.PrivatePatch(settings =>
@@ -85,7 +84,7 @@ protected override void
                     });
                 if (this.Linker is VisualCCommon.LinkerBase)
                 {
-                    this.LinkAgainst<WindowsSDK.WindowsSDK>();
+                    this.CompileAndLinkAgainst<WindowsSDK.WindowsSDK>(source);
                 }
             }
 
diff --git a/tests/MultiBitDepthModuleTest/bam/Scripts/MultiBitDepthModuleTest.cs b/tests/MultiBitDepthModuleTest/bam/Scripts/MultiBitDepthModuleTest.cs
@@ -50,7 +50,7 @@ protected override void
             if (this.BuildEnvironment.Platform.Includes(Bam.Core.EPlatform.Windows) &&
                 this.Linker is VisualCCommon.LinkerBase)
             {
-                this.CompilePubliclyAndLinkAgainst<WindowsSDK.WindowsSDK>(source);
+                this.CompileAndLinkAgainst<WindowsSDK.WindowsSDK>(source);
             }
         }
     }
@@ -75,7 +75,7 @@ protected override void
             if (this.BuildEnvironment.Platform.Includes(Bam.Core.EPlatform.Windows) &&
                 this.Linker is VisualCCommon.LinkerBase)
             {
-                this.CompilePubliclyAndLinkAgainst<WindowsSDK.WindowsSDK>(source);
+                this.CompileAndLinkAgainst<WindowsSDK.WindowsSDK>(source);
             }
         }
     }
diff --git a/tests/ObjectiveCTest1/bam/Scripts/ObjectiveCTest1.cs b/tests/ObjectiveCTest1/bam/Scripts/ObjectiveCTest1.cs
@@ -30,6 +30,7 @@
 using Bam.Core;
 namespace ObjectiveCTest1
 {
+    [Bam.Core.PlatformFilter(Bam.Core.EPlatform.Posix)]
     sealed class Program :
         C.ConsoleApplication
     {
diff --git a/tests/PublishingTest1/bam/Scripts/PublishingTest1.cs b/tests/PublishingTest1/bam/Scripts/PublishingTest1.cs
@@ -39,14 +39,11 @@ protected override void
         {
             base.Init(parent);
 
-            this.CreateCSourceContainer("$(packagedir)/source/main.c");
+            var source = this.CreateCSourceContainer("$(packagedir)/source/main.c");
 
-            if (this.BuildEnvironment.Platform.Includes(Bam.Core.EPlatform.Windows))
+            if (this.Linker is VisualCCommon.LinkerBase)
             {
-                if (this.Linker is VisualCCommon.LinkerBase)
-                {
-                    this.LinkAgainst<WindowsSDK.WindowsSDK>();
-                }
+                this.CompileAndLinkAgainst<WindowsSDK.WindowsSDK>(source);
             }
         }
     }
diff --git a/tests/Test/bam/Scripts/Test.cs b/tests/Test/bam/Scripts/Test.cs
@@ -146,7 +146,7 @@ protected override void
                 this.CreateWinResourceContainer("$(packagedir)/resources/win32.rc");
                 if (this.Linker is VisualCCommon.LinkerBase)
                 {
-                    this.CompilePubliclyAndLinkAgainst<WindowsSDK.WindowsSDK>(source);
+                    this.CompileAndLinkAgainst<WindowsSDK.WindowsSDK>(source);
                 }
             }
         }
diff --git a/tests/Test12/bam/Scripts/Test12.cs b/tests/Test12/bam/Scripts/Test12.cs
@@ -53,10 +53,9 @@ protected override void
                 source.AddFile("$(packagedir)/source/osx/osx.cpp");
             }
 
-            if (this.BuildEnvironment.Platform.Includes(Bam.Core.EPlatform.Windows) &&
-                this.Linker is VisualCCommon.LinkerBase)
+            if (this.Linker is VisualCCommon.LinkerBase)
             {
-                this.CompilePubliclyAndLinkAgainst<WindowsSDK.WindowsSDK>(source);
+                this.CompileAndLinkAgainst<WindowsSDK.WindowsSDK>(source);
 
                 this.PrivatePatch(settings =>
                     {
diff --git a/tests/Test15/bam/Scripts/Test15.cs b/tests/Test15/bam/Scripts/Test15.cs
@@ -76,6 +76,11 @@ protected override void
             // because DynamicLibrary1 pokes out of the public API of DynamicLibrary2, the dependency has to be marked
             // as 'public' so that forwarding occurs
             this.CompilePubliclyAndLinkAgainst<Test14.DynamicLibrary1>(source);
+
+            if (this.Linker is VisualCCommon.LinkerBase)
+            {
+                this.LinkAgainst<WindowsSDK.WindowsSDK>();
+            }
         }
     }
 }
diff --git a/tests/Test4/bam/Scripts/Test4.cs b/tests/Test4/bam/Scripts/Test4.cs
diff --git a/tests/Test8/bam/Scripts/Test8.cs b/tests/Test8/bam/Scripts/Test8.cs

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	+25-Mar-2016 Fixes #181. POTENTIALLY BREAKING CHANGE. Clarified the use of the 'public' utility functions in the C package. The CompilePubliclyAndLinkAgainst function has moved from C.ConsoleApplication to C.DynamicLibrary and C.Cxx.DynamicLibrary to enforce that 'public' inheritance of patches to dependents are not necessary for executables, but are for dynamic libraries. Added LinkPubliclyAgainst to C.DynamicLibrary and C.Cxx.DynamicLibrary. Added Bam.Core.Module.UsePublicPatchesPrivately, which takes the public patches from a dependent, but only applies them to the build of the current module, rather than forwarding them to any future dependees. Added more documentation to Bam.Core.Module regarding the application of patches. The likely changes to make to existing build scripts is to change CompilePubliclyAndLinkAgainst to CompileAndLinkAgainst in C.ConsoleApplication to C.GuiApplication (particularly for WindowsSDK), or that modules were previously compiling because patches had been leaked through prior to this change.
	`2`	`+`
`1`	`3`	`25-Mar-2016 Fixes #182. When the C# assembly for all the packages in a build fails to compile, an improved error message is now displayed, hinting at using the command line option in bam for enabling debug symbols, and the option to generate a debuggable project in one of the applicable IDEs (VisualStudio/Xamarin Studio/MonoDevelop).`
`2`	`4`
`3`	`5`	25-Mar-2016 Fixes #180. C.DynamicLibrary and C.Cxx.DynamicLibrary that identify dynamic library dependencies with CompilePubliclyAndLinkAgainst now forward those dependencies on, just like how StaticLibraries already do. If the public API in dynamic library D is exposed in the public API of dynamic library E, then it is legal for a compilation step dependent on D to invoke calls in E that were not resolved during D's link. This change simplifies writing build scripts in that transient dynamic dependencies no longer need to be manually specified.
Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,11 @@ protected override void`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
	`85`	`+ /// <summary>`
	`86`	`+ /// Compile against DependentModule.`
	`87`	`+ /// As this is a header only library, this dependency implies a public inheritence of DependentModule's public patches.`
	`88`	`+ /// </summary>`
	`89`	`+ /// <typeparam name="DependentModule">1st generic type</typeparam>`
`85`	`90`	`public void`
`86`	`91`	`CompileAgainst<DependentModule>() where DependentModule : CModule, new()`
`87`	`92`	`{`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ protected CompilerBase()`
`58`	`58`	`if (meta.UseWindowsSDKPublicPatches)`
`59`	`59`	`{`
`60`	`60`	`var windowsSDK = Bam.Core.Graph.Instance.FindReferencedModule<WindowsSDK.WindowsSDK>();`
`61`		`- this.UsePublicPatches(windowsSDK);`
	`61`	`+ this.UsePublicPatchesPrivately(windowsSDK);`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`
Original file line number	Diff line number	Diff line change
`@@ -44,10 +44,9 @@ protected override void`
`44`	`44`	`this.CompileAndLinkAgainst<CStaticLibrary>(source);`
`45`	`45`	`this.CompileAndLinkAgainst<CDynamicLibrary>(source);`
`46`	`46`
`47`		`- if (this.BuildEnvironment.Platform.Includes(EPlatform.Windows) &&`
`48`		`- this.Linker is VisualCCommon.LinkerBase)`
	`47`	`+ if (this.Linker is VisualCCommon.LinkerBase)`
`49`	`48`	`{`
`50`		`- this.LinkAgainst<WindowsSDK.WindowsSDK>();`
	`49`	`+ this.CompileAndLinkAgainst<WindowsSDK.WindowsSDK>(source);`
`51`	`50`	`}`
`52`	`51`
`53`	`52`	`this.PrivatePatch(settings =>`
`@@ -85,7 +84,7 @@ protected override void`
`85`	`84`	`});`
`86`	`85`	`if (this.Linker is VisualCCommon.LinkerBase)`
`87`	`86`	`{`
`88`		`- this.LinkAgainst<WindowsSDK.WindowsSDK>();`
	`87`	`+ this.CompileAndLinkAgainst<WindowsSDK.WindowsSDK>(source);`
`89`	`88`	`}`
`90`	`89`	`}`
`91`	`90`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ protected override void`
`50`	`50`	`if (this.BuildEnvironment.Platform.Includes(Bam.Core.EPlatform.Windows) &&`
`51`	`51`	`this.Linker is VisualCCommon.LinkerBase)`
`52`	`52`	`{`
`53`		`- this.CompilePubliclyAndLinkAgainst<WindowsSDK.WindowsSDK>(source);`
	`53`	`+ this.CompileAndLinkAgainst<WindowsSDK.WindowsSDK>(source);`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`	`}`
`@@ -75,7 +75,7 @@ protected override void`
`75`	`75`	`if (this.BuildEnvironment.Platform.Includes(Bam.Core.EPlatform.Windows) &&`
`76`	`76`	`this.Linker is VisualCCommon.LinkerBase)`
`77`	`77`	`{`
`78`		`- this.CompilePubliclyAndLinkAgainst<WindowsSDK.WindowsSDK>(source);`
	`78`	`+ this.CompileAndLinkAgainst<WindowsSDK.WindowsSDK>(source);`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,7 @@`
`30`	`30`	`using Bam.Core;`
`31`	`31`	`namespace ObjectiveCTest1`
`32`	`32`	`{`
	`33`	`+ [Bam.Core.PlatformFilter(Bam.Core.EPlatform.Posix)]`
`33`	`34`	`sealed class Program :`
`34`	`35`	`C.ConsoleApplication`
`35`	`36`	`{`