Continued implementation of usage and use

Author: nickclark2016

contrib/mbedtls/Makefile

@@ -382,11 +382,21 @@ if premake.action.supports("None") then
 
 		files ".github/**"
 
+		usage "SomeOtherUsage"
+			defines { "SOME_OTHER" }
+
+		usage "DebugOnlyUsage"
+			defines { "DEBUG_ONLY" }
+
 		usage "PUBLIC"
 			defines { "PUBLIC_GITHUB" }
+			uses { "SomeOtherUsage" }
 			filter { "configurations:Release" }
 				defines { "PUBLIC_GITHUB_RELEASE" }
 				includedirs { "/test/1/2/3" }
+			filter { "configurations:Debug" }
+				uses { "DebugOnlyUsage" }
+			filter {}
 
 		usage "RandomName"
 			defines { "RANDOM_DANCING" }

premake5.lua

@@ -1185,7 +1185,7 @@
 	api.register {
 		name = "uses",
 		scope = "config",
-		kind = "table"
+		kind = "list:string",
 	}
 
 

src/_premake_init.lua

@@ -356,7 +356,7 @@
 		context.addFilter(self, "architecture", self.architecture)
 		context.addFilter(self, "tags", self.tags)
 
-		self.usage = usage
+		self.usage = self
 
 		self.environ = {
 			wks = prj.workspace,
@@ -394,6 +394,8 @@
 			local buildcfg = pairing[1]
 			local platform = pairing[2]
 			local cfg = oven.bakeConfig(wks, prj, buildcfg, platform, nil, self)
+			cfg.usage = self
+			cfg._isusage = true
 
 			if p.action.supportsconfig(p.action.current(), cfg) then
 				self.configs[(buildcfg or "*") .. (platform or "")] = cfg
@@ -950,93 +952,101 @@
 			end
 		end
 
-		local function applyUsage(prj, usage)
-			-- For each configuration in the project, apply the corresponding configuration from the usage block
-			for cfg in p.project.eachconfig(prj) do
-				-- Merge the usage block into the project configuration
-				-- If the type of a field contains files, ensure the files are applied relative to the usage block's location
-				-- instead of target configuration's location
-
-				-- Find the usage configuration that corresponds to the project configuration
-				local match = p.project.findClosestMatch(usage, cfg.buildcfg, cfg.platform)
-				if match then
-					-- Merge the usage configuration into the project configuration
-					verbosef('      Applying usage %s:%s:%s to %s:%s', usage.project.name, usage.name, cfg.shortname, prj.name, cfg.shortname)
-					buildAppliedPropertyTable(prj, match)
-				end
-			end
-		end
+		local function fetchPropertiesToApply(src, tgt)
+			local properties = {}
+			local srcprj = src.project
 
+			verbosef('Applying properties from %s:%s to %s:%s', srcprj.name, src.name, tgt.project.name, tgt.shortname)
 
-		-- Build a table of all of the usage blocks in the workspace which are not a special
-		-- case (public, private, interface).
+			for k, v in pairs(src) do
+				verbosef('key = %s, value = %s', k, v)
+			end
 
-		verbosef('    Baking usages...')
-		local usages = {}
-		for wks in p.global.eachWorkspace() do
-			for prj in p.workspace.eachproject(wks) do
-				for _, usage in ipairs(prj.usages or {}) do
-					verbosef('      Found usage %s:%s:%s', wks.name, prj.name, usage.name)
-
-					if not p.usage.isSpecial(usage) then
-						-- Check if the usage block already exists in the table
-						local existing = usages[usage.name]
-						if not existing then
-							usages[usage.name] = usage
-						else
-							p.warn('Usage with name %s already exists in the workspace.')
-						end
+			return properties
+		end
+
+		local function collectUsages(cfg)
+			local uses = {}
+
+			for _, use in ipairs(cfg.uses or {}) do
+				-- Find a usage block that matches the usage name
+				local namematch = p.usage.findglobal(use)
+				for i = 1, #namematch do
+					local usagecfg = p.project.findClosestMatch(namematch[i], cfg.buildcfg, cfg.platform)
+					
+					if usagecfg then
+						-- Apply the usage block to the project configuration
+						local children = collectUsages(usagecfg)
+						uses = table.join(uses, children)
+					else
+						p.warnOnce('no-such-usage:' .. use, "Usage '%s' not found in project '%s'", use, cfg.project.name)
 					end
 				end
+
+				if #namematch > 0 then
+					table.insert(uses, use) -- Add use to the end, to preserve walking order
+				else					
+					p.warnOnce('no-such-usage:' .. use, "Usage '%s' not found in project '%s'", use, cfg.project.name)
+				end
 			end
+
+			return uses
 		end
 
+		local function collectSpecialUsages(usage, cfg)
+			local usagecfg = p.project.findClosestMatch(usage, cfg.buildcfg, cfg.platform)
+			if usagecfg then
+				local result = {}
+				local children = collectUsages(usagecfg)
+				
+				local uses = table.translate(children, function(use)
+					return p.usage.findglobal(use)
+				end)
+				
+				result = table.join(result, uses)
+				result = table.insert(result, usage)
+
+				return result
+			end
+
+			return {}
+		end
+
+		verbosef('    Baking usages...')
+
 		for wks in p.global.eachWorkspace() do
 			for prj in p.workspace.eachproject(wks) do
-				-- Check if the project has a PRIVATE or PUBLIC block
-				-- PUBLIC is applied to all, PRIVATE is applied to the project only
-				local publicusage = p.project.findusage(prj, p.usage.PUBLIC)
-				local interfaceusage = p.project.findusage(prj, p.usage.INTERFACE)
-
-				if publicusage then
-					applyUsage(prj, publicusage)
-				end
+				for cfg in p.project.eachconfig(prj) do
+					local usenames = collectUsages(cfg)
+					local uses = table.translate(usenames, function(use)
+						return p.usage.findglobal(use)
+					end)
+
+					-- Find a public usage block for the current project
+					local publicusage = p.project.findusage(prj, p.usage.PUBLIC)
+					if publicusage then
+						local children = collectSpecialUsages(publicusage, cfg)
+						uses = table.join(uses, children)
+					end
 
-				if interfaceusage then
-					applyUsage(prj, interfaceusage)
-				end
+					-- Find a private usage block for the current project
+					local privateusage = p.project.findusage(prj, p.usage.PRIVATE)
+					if privateusage then
+						local children = collectSpecialUsages(privateusage, cfg)
+						uses = table.join(uses, children)
+					end
 
-				local uses = prj.uses or {}
-				for _, usagename in ipairs(uses) do
-					-- Search priority:
-					-- 1. Search for a project with the same name as the usage
-					-- 2. Search for a usage with the same name as the usage
-					-- 3. Present a warning if no project or usage is found
-
-					local tgt = p.workspace.findproject(wks, usagename)
-					if tgt then
-						-- In the case of a project, search for public and interface blocks
-						local publicusage = p.project.findusage(tgt, p.usage.PUBLIC) -- public block
-						local interfaceusage = p.project.findusage(tgt, p.usage.INTERFACE) -- interface block
-
-						if publicusage then
-							applyUsage(prj, publicusage)
-						end
+					local allprops = {}
 
-						if interfaceusage then
-							applyUsage(prj, interfaceusage)
-						end
-					else
-						local usage = usages[usagename]
-						if usage then
-							applyUsage(prj, usage)
-						else
-							-- Present a warning if no project or usage is found
-							p.warn('Project %s uses %s, but no project or usage with that name was found', prj.name, usagename)
+					for _, usage in ipairs(uses) do
+						local props = fetchPropertiesToApply(usage[1], cfg)
+						
+						-- Handle duplicate properties
+						for key, value in pairs(props) do
+							allprops[key] = p.field.store(p.fields[key], allprops[key], value)
 						end
 					end
 				end
 			end
-
 		end
 	end

src/base/oven.lua

@@ -575,7 +575,7 @@
 	function project.findusage(self, name)
 		name = name:lower()
 
-		for _, usage in ipairs(self.usages) do
+		for _, usage in ipairs(self.usages or self.project.usages) do
 			if name == usage.name:lower() then
 				return usage
 			end

src/base/project.lua

@@ -42,3 +42,39 @@
     function usage.isSpecial(self)
         return self.name == usage.PUBLIC or self.name == usage.PRIVATE or self.name == usage.INTERFACE
     end
+
+
+    function usage.findglobal(name)
+        -- First, try to find a project with the provided name in the global scope
+        for wks in p.global.eachWorkspace() do
+            -- For each workspace, check if a project with the provided name exists
+            local prj = p.workspace.findproject(wks, name)
+            if prj then
+                -- Check if the project has a public or interface usage
+                local publicUsage = p.project.findusage(prj, usage.PUBLIC)
+                local interfaceUsage = p.project.findusage(prj, usage.INTERFACE)
+
+                local result = {}
+                if publicUsage then
+                    table.insert(result, publicUsage)
+                end
+
+                if interfaceUsage then
+                    table.insert(result, interfaceUsage)
+                end
+
+                return result
+            end
+
+            -- If no project with a matching name was found, check each project to see if it has a usage
+            -- with the provided name
+            for prj in p.workspace.eachproject(wks) do
+                local usage = p.project.findusage(prj, name)
+                if usage then
+                    return { usage }
+                end
+            end
+        end
+
+        return {}
+    end

src/base/usage.lua

@@ -0,0 +1,42 @@
+Specifies a reusable block of configuration to be consumed at a later point.
+
+```lua
+usage 'MyUsage'
+    defines { 'MY_DEFINE' }
+```
+
+The `usage` API is used to define configuration to be consumed by the `uses` API.  Usages must have unique names, except for magic usage block names (as described below).
+
+### Magic Usage Blocks ###
+
+1. `PRIVATE` - Private specifies a configuration to be automatically applied to the project defining the `usage` block. This block is inaccessible to be consumed by `uses`.
+2. `INTERFACE` - Interface has the opposite meaning as private usages. An interface usage is applied only to those projects consuming it via `uses`. Interface usage blocks are consumed by specfiying the containing project's name in the `uses` list.
+3. `PUBLIC` - Public specifies a configuration to be automatically applied to the project defining the `usage` block and any project consuming it via `uses`. Like `INTERFACE`, it is consumed by specifying the name of the project it is defined in.
+
+If projects define both an `INTERFACE` and `PUBLIC` usage block, both blocks will be applied to any project consuming that project.
+
+### Example ###
+
+```lua
+project 'A'
+    usage 'PRIVATE'
+        defines { 'A_PRIVATE' }
+    usage 'PUBLIC'
+        defines { 'A_PUBLIC' }
+    usage 'NotMagic'
+        defines { 'A_NOT_MAGIC' }
+
+project 'B'
+    uses { 'NotMagic' } -- Applies usage NotMagic from A
+
+    usage 'PUBLIC'
+        uses { 'A' } -- Applies PUBLIC from A to self and to any project consuming B
+```
+
+### Applies To ###
+
+Project configurations.
+
+### See Also ###
+
+* [uses](uses.md)

website/docs/usage.md

@@ -0,0 +1,22 @@
+Specifies which usage blocks a project should consume.
+
+```lua
+uses { "ProjectA" }
+```
+
+The `uses` API is used to consume `usage` blocks from within a project.
+
+### Usage resolve priority ###
+
+1. `PUBLIC` and `INTERFACE` usage scopes within a project of the corresponding name.
+2. `usage` blocks with the corresponding name in any scopes.
+
+Note: If there are duplicate usage blocks with the same resolved name, the selected usage block is unspecified. `usage` blocks should have unique names if they are not specified as `PUBLIC`, `PRIVATE`, or `INTERFACE`.
+
+### Applies To ###
+
+Projects and usage configurations.
+
+### See Also ###
+
+* [usage](usage.md)

website/docs/uses.md

@@ -271,8 +271,10 @@ module.exports = {
 						'toolset',
 						'toolsversion',
 						'undefines',
+						'usage',
 						'unsignedchar',
 						'usefullpaths',
+						'uses',
 						'usestandardpreprocessor',
 						'usingdirs',
 						'uuid',