Test-ModuleManifest doesn't work when RequiredModules are specified

[cholmes1111]

This is essentially a duplicate of closed issue 3663 which was marked as closed because while it failed in PowerShell 5.1 as the original poster commented, @SteveL-MSFT, indicated this works in PowerShell 6. I can not get it to work in 6.0.4.

I'm unclear as to why the required modules have to be installed locally before publishing. As part of the publishing process, a check is performed to ensure that the required modules are available on the repo. If the required modules are not available on the repo, the publishing of the module fails. If the required modules are found on the repo, the publishing of the module will succeed. With that workflow, why require them to be installed locally?

Steps to reproduce

New-ModuleManifest m.psd1 -RequiredModules sub
Test-ModuleManifest m.psd1 -verbose

Expected behavior

I'd expect it to return details on the module being tested. For example:

Test-ModuleManifest m.psd1 -Verbose

ModuleType Version    Name                                ExportedCommands
---------- -------    ----                                ----------------
Manifest   0.0.1      m

Actual behavior

I get an error

Test-ModuleManifest m.psd1 -Verbose
Test-ModuleManifest : The specified RequiredModules entry 'sub' in the module manifest 'C:\Inbox\m.psd1' is invalid. Try again after updating this entry with valid values.
At line:1 char:1
+ Test-ModuleManifest m.psd1 -Verbose
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ CategoryInfo          : ObjectNotFound: (m.psd1:String) [Test-ModuleManifest], DirectoryNotFoundException
+ FullyQualifiedErrorId : Modules_InvalidRequiredModulesinModuleManifest,Microsoft.PowerShell.Commands.TestModuleManifestCommand


ModuleType Version    Name                                ExportedCommands
---------- -------    ----                                ----------------
Manifest   0.0.1      m

Environment data

This happens in version 6.0.4 on both Windows and Ubunutu

Windows

> $PSVersionTable
Name                           Value
----                           -----
PSVersion                      6.0.4
PSEdition                      Core
GitCommitId                    v6.0.4
OS                             Microsoft Windows 10.0.14393
Platform                       Win32NT
PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0...}
PSRemotingProtocolVersion      2.3
SerializationVersion           1.1.0.1
WSManStackVersion              3.0

Ubuntu

> $PSVersionTable

Name                           Value
----                           -----
PSVersion                      6.0.4
PSEdition                      Core
GitCommitId                    v6.0.4
OS                             Linux 4.4.0-28-generic #47-Ubuntu SMP Fri Jun...
Platform                       Unix
PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0...}
PSRemotingProtocolVersion      2.3
SerializationVersion           1.1.0.1
WSManStackVersion              3.0

Workaround

To get around this limitation, we read in the data file information, create an array of the required modules and install each of them.

    # Get .psd1 data
    $data = Import-PowerShellDataFile .\*.psd1

    # Get the RequiredModules
    $requiredModules = $data.RequiredModules.ModuleName
    
    if ($requiredModules) {
        # Create credentials used to connect to private NuGet feed
        Write-Output 'Creating credentials'
        $pwd = ConvertTo-SecureString $NuGetApiKey -AsPlainText -Force
        $cred = New-Object Management.Automation.PSCredential ("username", $pwd)
        # Install the required modules
        foreach ($module in $requiredModules) {
            Install-Module $module -Repository $repo -Credential $cred -Verbose
        }
    }

While this works, it adds additional, unneeded overhead.

[cholmes1111]

Another quick follow up, when installing the required modules, you'll notice that I don't specify a version I always just grab the latest. The locally installed version of the required modules does NOT have to match the version specified in the required modules section of the .psd1.

If the workflow is going to force you to have the required modules installed locally, it should additionally ensure it's the correct version.

[mklement0]

@cholmes1111:

Good point about not enforcing the version; that bug has already been reported: #7495

That same report, created by @rjmholt, also suggests the following enhancement, which addresses your main issue:

Provide an option to only check the validity of the manifest itself, and not whether it will work in the current session (this last point I think is part of the need to separate "Module manifests that are not well-formed" from "Module manifests that cannot be loaded in the current session"

Note that this means that the default behavior would remain as-is (except for the need to fix the version bug), and that performing a test for mere well-formation would be opt-in.

---

In the meantime, you can use the stopgap demonstrated in this SO answer.

[cholmes1111]

@mklement0 - Thanks for the feedback! I didn't see the previously reported bug 7495 . I agree with @rjmholt on all of his points:

1. It should constrain on version
2. The error message should be improved
3. Test-ModuleManifest should have an opt-in for checking just the manifest for being well-formed

If Test-ModuleManifest is updated to have an opt-in, would Publish-Module be updated to check the manifests with that opt-in? I only encountered this issue when attempting to Publish-Module.

Thanks for the link to the stopgap as well. I'll give it a try and update my process accordingly if I can validate it works.

[ShaunInIdaho]

If you're like me and you've come across this page while searching for a solution to publishing modules from a container (Bitbucket/Azure DevOps) I have a very simple work around to this issue.

Problem

The problem is that Publish-Module runs Test-ModuleManifest which expects any requiredModules (which will include Externally Required modules) to be installed on the local file system. This is especially challenging when your module depends on modules from multiple external repos.

Solution

The thing is that Test-ModuleManifest just looks for the existence of the .psd1 file and doesn't care about the contents. I was able to work around this by simply identifying the location where modules are installed by default and then creating the module directory and an empty .psd1 file like this:

Function Build-RequiredModuleFiles {

  # Get .psd1 data
  $Data = Import-PowerShellDataFile .\*.psd1

  # Get the RequiredModules
  [array]$RequiredModules = $data.RequiredModules

  
  If ($RequiredModules) {

    Set-Location '/root/.local/share/powershell/Modules'

    # Create the required module manifests
    ForEach ($module in $requiredModules) {
      $moduleName = $module.ModuleName
      New-Item $moduleName -type Directory
      Write-Output "Creating empty .psd1 file for module $modulename at $((Get-Location).Path)\$moduleName\$moduleName.psd1"

      # Create manifest
      New-Item ".\$moduleName\$moduleName.psd1"
    }
  }
}

[iSazonov]

I think it makes no sense to create a module manifest if it can not be used or tested locally. Don't add RequiredModules if you have to ignore it on next step.

[nathan-alden-hp]

@iSazonov I agree, but unfortunately some hack is necessary due to Microsoft's overly-restrictive coding of Publish-Module and the underlying inflexibility of Test-ModuleManifest. This is actually a great workaround.

[rjmholt]

I think it makes no sense to create a module manifest if it can not be used or tested locally. Don't add RequiredModules if you have to ignore it on next step.

I would actually prefer Test-ModuleManifest to allow levels of validation from simple syntax validation, through semantic manifest validation, and up to machine-state validation (like that RequiredModules are installed). I think that especially makes sense for development scenarios with staged testing and publication.

Unfortunately the logic for all of this is currently bound in the largest method in the codebase (the only one that Visual Studio gives a code quality score of 0):

PowerShell/src/System.Management.Automation/engine/Modules/ModuleCmdletBase.cs

Lines 1461 to 3523 in a8213b5

	/// <summary>
	/// Routine to process the module manifest data language script.
	/// </summary>
	/// <param name="moduleManifestPath">The path to the manifest file.</param>
	/// <param name="manifestScriptInfo">The script info for the manifest script.</param>
	/// <param name="data">Contents of the module manifest.</param>
	/// <param name="localizedData">Contents of the localized module manifest.</param>
	/// <param name="manifestProcessingFlags">Processing flags (whether to write errors / load elements).</param>
	/// <param name="minimumVersion">The minimum version to check the manifest against.</param>
	/// <param name="maximumVersion">The maximum version to check the manifest against.</param>
	/// <param name="requiredVersion">The version to check the manifest against.</param>
	/// <param name="requiredModuleGuid">The module guid to check the manifest against.</param>
	/// <param name="options">The set of options that are used while importing a module.</param>
	/// <param name="containedErrors">Tracks if there were errors in the file.</param>
	/// <returns></returns>
	internal PSModuleInfo LoadModuleManifest(
	string moduleManifestPath,
	ExternalScriptInfo manifestScriptInfo,
	Hashtable data,
	Hashtable localizedData,
	ManifestProcessingFlags manifestProcessingFlags,
	Version minimumVersion,
	Version maximumVersion,
	Version requiredVersion,
	Guid? requiredModuleGuid,
	ref ImportModuleOptions options,
	ref bool containedErrors)
	{
	string message;
	var bailOnFirstError = manifestProcessingFlags.HasFlag(ManifestProcessingFlags.NullOnFirstError);
	var importingModule = manifestProcessingFlags.HasFlag(ManifestProcessingFlags.LoadElements);
	var writingErrors = manifestProcessingFlags.HasFlag(ManifestProcessingFlags.WriteErrors);
	Dbg.Assert(moduleManifestPath != null, "moduleManifestPath for module (.psd1) can't be null");
	string moduleBase = Path.GetDirectoryName(moduleManifestPath);
	if ((manifestProcessingFlags &
	(ManifestProcessingFlags.LoadElements | ManifestProcessingFlags.WriteErrors |
	ManifestProcessingFlags.WriteWarnings)) != 0)
	{
	Context.ModuleBeingProcessed = moduleManifestPath;
	}
	// START: Check if the ModuleToProcess is already loaded..if it is, ignore the this load manifest
	// call and return
	string moduleToProcess = null;
	if (!GetScalarFromData<string>(data, moduleManifestPath, "ModuleToProcess", manifestProcessingFlags, out moduleToProcess))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	string rootModule = null;
	if (!GetScalarFromData<string>(data, moduleManifestPath, "RootModule", manifestProcessingFlags, out rootModule))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	if (!string.IsNullOrEmpty(moduleToProcess))
	{
	// If we've found ourselves, then skip writing the warning and move on.
	// Win8: 297326
	if (string.IsNullOrEmpty(Context.ModuleBeingProcessed) ||
	(!Context.ModuleBeingProcessed.Equals(moduleManifestPath, StringComparison.OrdinalIgnoreCase) ||
	!Context.ModuleBeingProcessed.Equals(Context.PreviousModuleProcessed,
	StringComparison.OrdinalIgnoreCase)))
	{
	if ((manifestProcessingFlags & ManifestProcessingFlags.WriteWarnings) != 0)
	{
	WriteWarning(Modules.ModuleToProcessFieldDeprecated);
	}
	}
	}
	if (!string.IsNullOrEmpty(moduleToProcess) && !string.IsNullOrEmpty(rootModule))
	{
	// If we've found ourselves, then skip writing the error and move on.
	// Win8 :330612
	if (string.IsNullOrEmpty(Context.ModuleBeingProcessed) ||
	(!Context.ModuleBeingProcessed.Equals(moduleManifestPath, StringComparison.OrdinalIgnoreCase) ||
	!Context.ModuleBeingProcessed.Equals(Context.PreviousModuleProcessed,
	StringComparison.OrdinalIgnoreCase)))
	{
	// Having both ModuleToProcess and RootModule is not allowed
	if (writingErrors)
	{
	message = StringUtil.Format(Modules.ModuleManifestCannotContainBothModuleToProcessAndRootModule,
	moduleManifestPath);
	InvalidOperationException ioe = new InvalidOperationException(message);
	ErrorRecord er = new ErrorRecord(ioe,
	"Modules_ModuleManifestCannotContainBothModuleToProcessAndRootModule",
	ErrorCategory.InvalidOperation, moduleManifestPath);
	WriteError(er);
	}
	}
	if (bailOnFirstError) return null;
	}
	string actualRootModule = moduleToProcess ?? rootModule;
	// extract defaultCommandPrefix from the manifest
	string defaultCommandPrefix = null;
	if (
	!GetScalarFromData<string>(data, moduleManifestPath, "DefaultCommandPrefix", manifestProcessingFlags,
	out defaultCommandPrefix))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	string resolvedCommandPrefix = string.Empty;
	if (!string.IsNullOrEmpty(defaultCommandPrefix))
	{
	resolvedCommandPrefix = defaultCommandPrefix;
	}
	if (!string.IsNullOrEmpty(this.BasePrefix))
	{
	resolvedCommandPrefix = this.BasePrefix;
	}
	if (!string.IsNullOrEmpty(actualRootModule))
	{
	if (WildcardPattern.ContainsWildcardCharacters(actualRootModule))
	{
	PSInvalidOperationException invalidOperation = PSTraceSource.NewInvalidOperationException(
	Modules.WildCardNotAllowedInModuleToProcessAndInNestedModules,
	moduleManifestPath);
	invalidOperation.SetErrorId("Modules_WildCardNotAllowedInModuleToProcessAndInNestedModules");
	throw invalidOperation;
	}
	// See if this module is already loaded. Since the manifest entry may not
	// have an extension and the module table is indexed by full names, we
	// may have search through all the extensions.
	PSModuleInfo loadedModule = null;
	string rootedPath = this.FixupFileName(moduleBase, actualRootModule, extension: null, importingModule);
	string mtpExtension = Path.GetExtension(rootedPath);
	if (!string.IsNullOrEmpty(mtpExtension) && ModuleIntrinsics.IsPowerShellModuleExtension(mtpExtension))
	{
	TryGetFromModuleTable(rootedPath, out loadedModule);
	}
	else
	{
	foreach (string extensionToTry in ModuleIntrinsics.PSModuleExtensions)
	{
	rootedPath = this.FixupFileName(moduleBase, actualRootModule, extensionToTry, importingModule);
	TryGetFromModuleTable(rootedPath, out loadedModule);
	if (loadedModule != null)
	break;
	}
	}
	if (importingModule && DoesAlreadyLoadedModuleSatisfyConstraints(loadedModule))
	{
	if (!BaseForce)
	{
	AddModuleToModuleTables(this.Context, this.TargetSessionState.Internal, loadedModule);
	// Even if the module has been loaded, import the specified members...
	ImportModuleMembers(loadedModule, resolvedCommandPrefix, options);
	return loadedModule;
	}
	// remove the module if force is specified (and if module is already loaded)
	else if (File.Exists(rootedPath))
	{
	RemoveModule(loadedModule);
	}
	}
	}
	// END: Check if the ModuleToProcess is already loaded..
	string author = string.Empty;
	if (!GetScalarFromData(data, moduleManifestPath, "Author", manifestProcessingFlags, out author))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	string companyName = string.Empty;
	if (!GetScalarFromData(data, moduleManifestPath, "CompanyName", manifestProcessingFlags, out companyName))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	string copyright = string.Empty;
	if (!GetScalarFromData(data, moduleManifestPath, "Copyright", manifestProcessingFlags, out copyright))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	Guid? manifestGuid;
	if (!GetScalarFromData(data, moduleManifestPath, "guid", manifestProcessingFlags, out manifestGuid))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	// Verify that the module manifest contains the module version information
	Version moduleVersion;
	if (
	!GetScalarFromData<Version>(data, moduleManifestPath, "ModuleVersion", manifestProcessingFlags,
	out moduleVersion))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	else
	{
	if (moduleVersion == null)
	{
	containedErrors = true;
	if (writingErrors)
	{
	message = StringUtil.Format(Modules.ModuleManifestMissingModuleVersion, moduleManifestPath);
	MissingMemberException mm = new MissingMemberException(message);
	ErrorRecord er = new ErrorRecord(mm, "Modules_InvalidManifest",
	ErrorCategory.ResourceUnavailable, moduleManifestPath);
	WriteError(er);
	}
	if (bailOnFirstError) return null;
	}
	else if (!ModuleIntrinsics.AreModuleFieldsMatchingConstraints(
	moduleGuid: manifestGuid,
	moduleVersion: moduleVersion,
	requiredGuid: requiredModuleGuid,
	requiredVersion: requiredVersion,
	minimumRequiredVersion: minimumVersion,
	maximumRequiredVersion: maximumVersion))
	{
	if (bailOnFirstError)
	{
	return null;
	}
	}
	// Verify that the module version from the module manifest is equal to module version folder.
	DirectoryInfo parent = null;
	try
	{
	parent = Directory.GetParent(moduleManifestPath);
	}
	catch (IOException)
	{
	}
	catch (UnauthorizedAccessException)
	{
	}
	catch (ArgumentException)
	{
	}
	Version moduleVersionFromFolderName;
	if (parent != null &&
	Version.TryParse(parent.Name, out moduleVersionFromFolderName) &&
	parent.Parent != null &&
	parent.Parent.Name.Equals(Path.GetFileNameWithoutExtension(moduleManifestPath)))
	{
	if (!moduleVersionFromFolderName.Equals(moduleVersion))
	{
	containedErrors = true;
	if (writingErrors)
	{
	message = StringUtil.Format(Modules.InvalidModuleManifestVersion, moduleManifestPath,
	moduleVersion.ToString(), parent.FullName);
	var ioe = new InvalidOperationException(message);
	var er = new ErrorRecord(ioe, "Modules_InvalidModuleManifestVersion",
	ErrorCategory.InvalidArgument, moduleManifestPath);
	WriteError(er);
	}
	if (bailOnFirstError) return null;
	}
	}
	}
	// Test that the PowerShellVersion version is valid...
	Version powerShellVersion;
	if (
	!GetScalarFromData<Version>(data, moduleManifestPath, "PowerShellVersion", manifestProcessingFlags,
	out powerShellVersion))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	else if (powerShellVersion != null)
	{
	Version currentPowerShellVersion = PSVersionInfo.PSVersion;
	if (currentPowerShellVersion < powerShellVersion)
	{
	containedErrors = true;
	if (writingErrors)
	{
	message = StringUtil.Format(Modules.ModuleManifestInsufficientPowerShellVersion,
	currentPowerShellVersion,
	moduleManifestPath, powerShellVersion);
	InvalidOperationException ioe = new InvalidOperationException(message);
	ErrorRecord er = new ErrorRecord(ioe, "Modules_InsufficientPowerShellVersion",
	ErrorCategory.ResourceUnavailable, moduleManifestPath);
	WriteError(er);
	}
	if (bailOnFirstError) return null;
	}
	}
	// Test that the PowerShellHostVersion version is valid...
	string requestedHostName;
	if (
	!GetScalarFromData(data, moduleManifestPath, "PowerShellHostName", manifestProcessingFlags,
	out requestedHostName))
	{
	containedErrors = true;
	// Ignore errors related to HostVersion as per the ManifestProcessingFlags
	// doing this at this place because we have to set "containedErrors"
	if (((manifestProcessingFlags & ManifestProcessingFlags.IgnoreHostNameAndHostVersion) == 0) &&
	bailOnFirstError)
	return null;
	}
	else if (requestedHostName != null)
	{
	string currentHostName = this.Context.InternalHost.Name;
	if (!string.Equals(currentHostName, requestedHostName, StringComparison.OrdinalIgnoreCase))
	{
	containedErrors = true;
	// Ignore errors related to HostVersion as per the ManifestProcessingFlags
	// doing this at this place because we have to set "containedErrors"
	if ((manifestProcessingFlags & ManifestProcessingFlags.IgnoreHostNameAndHostVersion) == 0)
	{
	if (writingErrors)
	{
	message = StringUtil.Format(Modules.InvalidPowerShellHostName,
	currentHostName, moduleManifestPath, requestedHostName);
	InvalidOperationException ioe = new InvalidOperationException(message);
	ErrorRecord er = new ErrorRecord(ioe, "Modules_InvalidPowerShellHostName",
	ErrorCategory.ResourceUnavailable, moduleManifestPath);
	WriteError(er);
	}
	if (bailOnFirstError) return null;
	}
	}
	}
	// Test that the PowerShellHostVersion version is valid...
	Version requestedHostVersion;
	if (
	!GetScalarFromData(data, moduleManifestPath, "PowerShellHostVersion", manifestProcessingFlags,
	out requestedHostVersion))
	{
	containedErrors = true;
	// Ignore errors related to HostVersion as per the ManifestProcessingFlags
	// doing this at this place because we have to set "containedErrors"
	if (((manifestProcessingFlags & ManifestProcessingFlags.IgnoreHostNameAndHostVersion) == 0) &&
	bailOnFirstError)
	return null;
	}
	else if (requestedHostVersion != null)
	{
	Version currentHostVersion = this.Context.InternalHost.Version;
	if (currentHostVersion < requestedHostVersion)
	{
	containedErrors = true;
	// Ignore errors related to HostVersion as per the ManifestProcessingFlags
	// doing this at this place because we have to set "containedErrors"
	if ((manifestProcessingFlags & ManifestProcessingFlags.IgnoreHostNameAndHostVersion) == 0)
	{
	if (writingErrors)
	{
	string currentHostName = this.Context.InternalHost.Name;
	message = StringUtil.Format(Modules.InvalidPowerShellHostVersion,
	currentHostName, currentHostVersion, moduleManifestPath, requestedHostVersion);
	InvalidOperationException ioe = new InvalidOperationException(message);
	ErrorRecord er = new ErrorRecord(ioe, "Modules_InsufficientPowerShellHostVersion",
	ErrorCategory.ResourceUnavailable, moduleManifestPath);
	WriteError(er);
	}
	if (bailOnFirstError) return null;
	}
	}
	}
	// Test the required processor architecture
	ProcessorArchitecture requiredProcessorArchitecture;
	if (
	!GetScalarFromData(data, moduleManifestPath, "ProcessorArchitecture", manifestProcessingFlags,
	out requiredProcessorArchitecture))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	else if ((requiredProcessorArchitecture != ProcessorArchitecture.None) &&
	(requiredProcessorArchitecture != ProcessorArchitecture.MSIL))
	{
	ProcessorArchitecture currentArchitecture = typeof(object).Assembly.GetName().ProcessorArchitecture;
	if (currentArchitecture != requiredProcessorArchitecture)
	{
	containedErrors = true;
	if (writingErrors)
	{
	message = StringUtil.Format(Modules.InvalidProcessorArchitecture,
	currentArchitecture, moduleManifestPath, requiredProcessorArchitecture);
	InvalidOperationException ioe = new InvalidOperationException(message);
	ErrorRecord er = new ErrorRecord(ioe, "Modules_InvalidProcessorArchitecture",
	ErrorCategory.ResourceUnavailable, moduleManifestPath);
	WriteError(er);
	}
	if (bailOnFirstError) return null;
	}
	}
	// Test the required CLR version
	Version requestedClrVersion;
	if (
	!GetScalarFromData(data, moduleManifestPath, "CLRVersion", manifestProcessingFlags,
	out requestedClrVersion))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	// Test the required .NET Framework version
	Version requestedDotNetFrameworkVersion;
	if (
	!GetScalarFromData(data, moduleManifestPath, "DotNetFrameworkVersion", manifestProcessingFlags,
	out requestedDotNetFrameworkVersion))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	// HelpInfo URI
	string helpInfoUri = null;
	GetScalarFromData<string>(data, moduleManifestPath, "HelpInfoURI", manifestProcessingFlags, out helpInfoUri);
	List<PSModuleInfo> requiredModulesLoaded = new List<PSModuleInfo>();
	// In case of Get-Module -List and Test-ModuleManifest, we populate this list with fake PSModuleInfo for each of the required modules specified
	List<PSModuleInfo> requiredModulesSpecifiedInModuleManifest = new List<PSModuleInfo>();
	ModuleSpecification[] requiredModules;
	if (
	!GetScalarFromData(data, moduleManifestPath, "RequiredModules", manifestProcessingFlags,
	out requiredModules))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	else if ((requiredModules != null))
	{
	if (importingModule)
	{
	// We need to pass in the moduleInfo of current module so that we can check for cyclic dependency in RequiredModules specification.
	// When a module A that has a required module B is imported (either explicitly or via auto-loading),
	// the current scope's module gets set to module A incorrectly. This leads to issues where the exported commands
	// of a module that imports module A) get added to module A instead of the actual module that is getting imported.
	// (Direct cause of Win8:336812)
	PSModuleInfo fakeManifestInfo = new PSModuleInfo(moduleManifestPath, Context, null);
	if (manifestGuid.HasValue)
	{
	fakeManifestInfo.SetGuid(manifestGuid.Value);
	}
	if (moduleVersion != null)
	{
	fakeManifestInfo.SetVersion(moduleVersion);
	}
	foreach (ModuleSpecification requiredModule in requiredModules)
	{
	// The required module name is essentially raw user input.
	// We must process it so paths work.
	ModuleSpecification normalizedRequiredModuleSpec = requiredModule?.WithNormalizedName(Context, moduleBase);
	ErrorRecord error = null;
	PSModuleInfo module = LoadRequiredModule(fakeManifestInfo, normalizedRequiredModuleSpec, moduleManifestPath,
	manifestProcessingFlags, containedErrors, out error);
	if (module == null && error != null)
	{
	WriteError(error);
	return null;
	}
	// module can be null (in case the RequiredModule has already been added as a snapin.
	// In that case, we just emit a warning and do not add the snapin to the list of requiredmodules)
	if (module != null)
	{
	requiredModulesLoaded.Add(module);
	}
	}
	}
	else
	{
	foreach (PSModuleInfo fakeRequiredModuleInfo in CreateFakeModuleObject(requiredModules))
	{
	requiredModulesSpecifiedInModuleManifest.Add(fakeRequiredModuleInfo);
	}
	}
	}
	// Validate the list of nestedModules...
	ModuleSpecification[] tmpNestedModules;
	if (
	!GetScalarFromData(data, moduleManifestPath, "NestedModules", manifestProcessingFlags,
	out tmpNestedModules))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	List<ModuleSpecification> nestedModules = new List<ModuleSpecification>();
	if (tmpNestedModules != null && tmpNestedModules.Length > 0)
	{
	foreach (ModuleSpecification s in tmpNestedModules)
	{
	s.Name = GetAbsolutePath(moduleBase, s.Name);
	if (WildcardPattern.ContainsWildcardCharacters(s.Name))
	{
	PSInvalidOperationException invalidOperation = PSTraceSource.NewInvalidOperationException(
	Modules.WildCardNotAllowedInModuleToProcessAndInNestedModules,
	moduleManifestPath);
	invalidOperation.SetErrorId("Modules_WildCardNotAllowedInModuleToProcessAndInNestedModules");
	throw invalidOperation;
	}
	nestedModules.Add(s);
	}
	Array.Clear(tmpNestedModules, 0, tmpNestedModules.Length);
	}
	// Set the private data member for the module if the manifest contains this member
	object privateData = data["PrivateData"];
	// Validate the 'ExperimentalFeatures' member of the manifest
	List<ExperimentalFeature> expFeatureList = null;
	if (privateData is Hashtable hashData && hashData["PSData"] is Hashtable psData)
	{
	if (!GetScalarFromData(psData, moduleManifestPath, "ExperimentalFeatures", manifestProcessingFlags, out Hashtable[] features))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	if (features != null && features.Length > 0)
	{
	bool nameMissingOrEmpty = false;
	var invalidNames = new List<string>();
	string moduleName = ModuleIntrinsics.GetModuleName(moduleManifestPath);
	expFeatureList = new List<ExperimentalFeature>(features.Length);
	foreach (Hashtable feature in features)
	{
	string featureName = feature["Name"] as string;
	if (string.IsNullOrEmpty(featureName))
	{
	nameMissingOrEmpty = true;
	}
	else if (ExperimentalFeature.IsModuleFeatureName(featureName, moduleName))
	{
	string featureDescription = feature["Description"] as string;
	expFeatureList.Add(new ExperimentalFeature(featureName, featureDescription, moduleManifestPath,
	ExperimentalFeature.IsEnabled(featureName)));
	}
	else
	{
	invalidNames.Add(featureName);
	}
	}
	if (nameMissingOrEmpty)
	{
	if (writingErrors)
	{
	WriteError(new ErrorRecord(new ArgumentException(Modules.ExperimentalFeatureNameMissingOrEmpty),
	"Modules_ExperimentalFeatureNameMissingOrEmpty",
	ErrorCategory.InvalidData, null));
	}
	containedErrors = true;
	if (bailOnFirstError) { return null; }
	}
	if (invalidNames.Count > 0)
	{
	if (writingErrors)
	{
	string invalidNameStr = string.Join(", ", invalidNames);
	string errorMsg = StringUtil.Format(Modules.InvalidExperimentalFeatureName, invalidNameStr);
	WriteError(new ErrorRecord(new ArgumentException(errorMsg),
	"Modules_InvalidExperimentalFeatureName",
	ErrorCategory.InvalidData, null));
	}
	containedErrors = true;
	if (bailOnFirstError) { return null; }
	}
	}
	}
	// Process all of the exports...
	List<WildcardPattern> exportedFunctions;
	if (
	!GetListOfWildcardsFromData(data, moduleManifestPath, "FunctionsToExport", manifestProcessingFlags,
	out exportedFunctions))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	List<WildcardPattern> exportedVariables;
	if (
	!GetListOfWildcardsFromData(data, moduleManifestPath, "VariablesToExport", manifestProcessingFlags,
	out exportedVariables))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	List<WildcardPattern> exportedAliases;
	if (
	!GetListOfWildcardsFromData(data, moduleManifestPath, "AliasesToExport", manifestProcessingFlags,
	out exportedAliases))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	List<WildcardPattern> exportedCmdlets;
	if (
	!GetListOfWildcardsFromData(data, moduleManifestPath, "CmdletsToExport", manifestProcessingFlags,
	out exportedCmdlets))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	List<WildcardPattern> exportedDscResources;
	if (
	!GetListOfWildcardsFromData(data, moduleManifestPath, "DscResourcesToExport", manifestProcessingFlags,
	out exportedDscResources))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	InitialSessionState iss = null;
	if (importingModule)
	{
	iss = InitialSessionState.Create();
	if (Context.InitialSessionState != null)
	{
	iss.DisableFormatUpdates = Context.InitialSessionState.DisableFormatUpdates;
	}
	// We want the processing errors to terminate module import.
	iss.ThrowOnRunspaceOpenError = true;
	}
	// Indicates the ISS.Bind() should be called...
	bool doBind = false;
	// Set up to load any required assemblies that have been specified...
	List<string> tmpAssemblyList;
	List<string> assemblyList = new List<string>();
	List<string> fixedUpAssemblyPathList = new List<string>();
	if (
	!GetListOfStringsFromData(data, moduleManifestPath, "RequiredAssemblies", manifestProcessingFlags,
	out tmpAssemblyList))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	else
	{
	if (tmpAssemblyList != null && tmpAssemblyList.Count > 0)
	{
	foreach (string assembly in tmpAssemblyList)
	{
	assemblyList.Add(assembly);
	}
	}
	if ((assemblyList != null) && importingModule)
	{
	foreach (string assembly in assemblyList)
	{
	if (WildcardPattern.ContainsWildcardCharacters(assembly))
	{
	PSInvalidOperationException invalidOperation = PSTraceSource.NewInvalidOperationException(
	Modules.WildCardNotAllowedInRequiredAssemblies,
	moduleManifestPath);
	invalidOperation.SetErrorId("Modules_WildCardNotAllowedInRequiredAssemblies");
	throw invalidOperation;
	}
	else
	{
	string fileName = FixupFileName(moduleBase, assembly, StringLiterals.PowerShellNgenAssemblyExtension, importingModule, out bool pathIsResolved);
	if (!pathIsResolved)
	{
	fileName = FixupFileName(moduleBase, assembly, StringLiterals.PowerShellILAssemblyExtension, importingModule);
	}
	string loadMessage = StringUtil.Format(Modules.LoadingFile, "Assembly", fileName);
	WriteVerbose(loadMessage);
	iss.Assemblies.Add(new SessionStateAssemblyEntry(assembly, fileName));
	fixedUpAssemblyPathList.Add(fileName);
	fileName = FixupFileName(moduleBase, assembly, StringLiterals.PowerShellILExecutableExtension, importingModule);
	loadMessage = StringUtil.Format(Modules.LoadingFile, "Executable", fileName);
	WriteVerbose(loadMessage);
	iss.Assemblies.Add(new SessionStateAssemblyEntry(assembly, fileName));
	fixedUpAssemblyPathList.Add(fileName);
	doBind = true;
	}
	}
	}
	}
	// Set up to load any types files that have been specified...
	if (!GetListOfFilesFromData(
	data,
	moduleManifestPath,
	key: "TypesToProcess",
	manifestProcessingFlags,
	moduleBase,
	extension: ".ps1xml",
	verifyFilesExist: true,
	out List<string> exportedTypeFiles))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	else
	{
	if ((exportedTypeFiles != null) && importingModule)
	{
	foreach (string fileName in exportedTypeFiles)
	{
	string loadMessage = StringUtil.Format(Modules.LoadingFile, "TypesToProcess", fileName);
	WriteVerbose(loadMessage);
	bool isAlreadyLoaded = false;
	string resolvedFileName = ResolveRootedFilePath(fileName, Context) ?? fileName;
	foreach (var entry in Context.InitialSessionState.Types)
	{
	if (entry.FileName == null)
	{
	continue;
	}
	string resolvedEntryFileName = ResolveRootedFilePath(entry.FileName, Context) ??
	entry.FileName;
	if (resolvedEntryFileName.Equals(resolvedFileName, StringComparison.OrdinalIgnoreCase))
	{
	isAlreadyLoaded = true;
	break;
	}
	}
	if (!isAlreadyLoaded)
	{
	iss.Types.Add(new SessionStateTypeEntry(fileName));
	doBind = true;
	}
	}
	}
	}
	// Set up to load any format files that have been specified...
	if (!GetListOfFilesFromData(
	data,
	moduleManifestPath,
	key: "FormatsToProcess",
	manifestProcessingFlags,
	moduleBase,
	extension: ".ps1xml",
	verifyFilesExist: true,
	out List<string> exportedFormatFiles))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	else
	{
	if ((exportedFormatFiles != null) && importingModule)
	{
	foreach (string fileName in exportedFormatFiles)
	{
	string loadMessage = StringUtil.Format(Modules.LoadingFile, "FormatsToProcess", fileName);
	WriteVerbose(loadMessage);
	bool isAlreadyLoaded = false;
	foreach (var entry in Context.InitialSessionState.Formats)
	{
	if (entry.FileName == null)
	{
	continue;
	}
	if (entry.FileName.Equals(fileName, StringComparison.OrdinalIgnoreCase))
	{
	isAlreadyLoaded = true;
	break;
	}
	}
	if (!isAlreadyLoaded)
	{
	iss.Formats.Add(new SessionStateFormatEntry(fileName));
	doBind = true;
	}
	}
	}
	}
	// scripts to process
	if (!GetListOfFilesFromData(
	data,
	moduleManifestPath,
	key: "ScriptsToProcess",
	manifestProcessingFlags,
	moduleBase,
	extension: ".ps1",
	verifyFilesExist: true,
	out List<string> scriptsToProcess))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	else
	{
	if ((scriptsToProcess != null) && importingModule)
	{
	foreach (string scriptFile in scriptsToProcess)
	{
	if (!Path.GetExtension(scriptFile).Equals(".ps1", StringComparison.OrdinalIgnoreCase))
	{
	string errorMessage = StringUtil.Format(Modules.ScriptsToProcessIncorrectExtension,
	scriptFile);
	InvalidOperationException ioe = new InvalidOperationException(errorMessage);
	WriteInvalidManifestMemberError(this, "ScriptsToProcess", moduleManifestPath, ioe,
	manifestProcessingFlags);
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	}
	}
	}
	// Now add the metadata to the module info object for the manifest...
	string description = string.Empty;
	if (data.Contains("Description"))
	{
	if (localizedData != null && localizedData.Contains("Description"))
	{
	description = (string)LanguagePrimitives.ConvertTo(localizedData["Description"],
	typeof(string), CultureInfo.InvariantCulture);
	}
	if (string.IsNullOrEmpty(description))
	{
	description = (string)LanguagePrimitives.ConvertTo(data["Description"],
	typeof(string), CultureInfo.InvariantCulture);
	}
	}
	// Process "FileList"
	if (!GetListOfFilesFromData(
	data,
	moduleManifestPath,
	key: "FileList",
	manifestProcessingFlags,
	moduleBase,
	extension: string.Empty,
	// Don't check file existence - don't want to change current behavior without feature team discussion.
	verifyFilesExist: false,
	out List<string> fileList))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	// Process "ModuleList
	ModuleSpecification[] moduleList;
	if (
	!GetScalarFromData<ModuleSpecification[]>(data, moduleManifestPath, "ModuleList",
	manifestProcessingFlags, out moduleList))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	// Process "CompatiblePSEditions"
	string[] compatiblePSEditions;
	if (
	!GetScalarFromData<string[]>(data, moduleManifestPath, "CompatiblePSEditions",
	manifestProcessingFlags, out compatiblePSEditions))
	{
	containedErrors = true;
	if (bailOnFirstError) return null;
	}
	// On Windows, we want to include any modules under %WINDIR%\System32\WindowsPowerShell\v1.0\Modules
	// that have declared compatibility with PS Core (or if the check is skipped)
	IEnumerable<string> inferredCompatiblePSEditions = compatiblePSEditions ?? DefaultCompatiblePSEditions;
	bool isConsideredCompatible = ModuleUtils.IsPSEditionCompatible(moduleManifestPath, inferredCompatiblePSEditions);
	if (!BaseSkipEditionCheck && !isConsideredCompatible)
	{
	if (PowerShellConfig.Instance.IsImplicitWinCompatEnabled())
	{
	if (importingModule)
	{
	IList<PSModuleInfo> moduleProxies = ImportModulesUsingWinCompat(new string[] { moduleManifestPath }, null, options);
	// we are loading by a single ManifestPath so expect max of 1
	if (moduleProxies.Count > 0)
	{
	return moduleProxies[0];
	}
	else
	{
	return null;
	}
	}
	}
	else
	{
	containedErrors = true;
	if (writingErrors)
	{
	message = StringUtil.Format(
	Modules.ImplicitWinCompatDisabled,
	moduleManifestPath,
	string.Join(',', inferredCompatiblePSEditions));
	ErrorRecord er = new ErrorRecord(
	new InvalidOperationException(message),
	nameof(Modules) + "_" + nameof(Modules.ImplicitWinCompatDisabled),
	ErrorCategory.ResourceUnavailable,
	moduleManifestPath);
	WriteError(er);
	}
	if (bailOnFirstError)
	{
	// If we're trying to load the module, return null so that caches
	// are not polluted
	if (importingModule)
	{
	return null;
	}
	// If we return null with Get-Module, a fake module info will be created. Since
	// we want to suppress output of the module, we need to do that here.
	return new PSModuleInfo(moduleManifestPath, context: null, sessionState: null)
	{
	HadErrorsLoading = true,
	IsConsideredEditionCompatible = false,
	};
	}
	}
	}
	// Process format.ps1xml / types.ps1.xml / RequiredAssemblies
	// as late as possible, but before ModuleToProcess, ScriptToProcess, NestedModules
	if (importingModule)
	{
	// Do the InitialSessionState binding...
	if (doBind)
	{
	try
	{
	iss.Bind(Context, updateOnly: true, module: null, noClobber: false, local: false, setLocation: false);
	}
	catch (Exception e)
	{
	this.RemoveTypesAndFormatting(exportedFormatFiles, exportedTypeFiles);
	ErrorRecord er = new ErrorRecord(e, "FormatXmlUpdateException", ErrorCategory.InvalidOperation,
	null);
	if (bailOnFirstError)
	{
	this.ThrowTerminatingError(er);
	}
	else if (writingErrors)
	{
	this.WriteError(er);
	}
	}
	}
	}
	// Create a PSModuleInfo for psd1 file or take one from ModuleToProcess manifest field
	// SessionState is created for psd1 file or taken from ModuleToProcess module (unless it is a binary module)
	// If we're loading the manifest, allocate a session state object for it...
	var ss = importingModule ? new SessionState(Context, true, true) : null;
	var manifestInfo = new PSModuleInfo(moduleManifestPath, Context, ss);
	// Default to a Manifest module type...
	manifestInfo.SetModuleType(ModuleType.Manifest);
	if (importingModule)
	{
	SetModuleLoggingInformation(manifestInfo);
	}
	if (requiredModulesSpecifiedInModuleManifest != null && requiredModulesSpecifiedInModuleManifest.Count > 0)
	{
	foreach (var module in requiredModulesSpecifiedInModuleManifest)
	{
	manifestInfo.AddRequiredModule(module);
	}
	}
	// If there is a session state, set up to import/export commands and variables
	if (ss != null)
	{
	ss.Internal.SetVariable(SpecialVariables.PSScriptRootVarPath, Path.GetDirectoryName(moduleManifestPath),
	true, CommandOrigin.Internal);
	ss.Internal.SetVariable(SpecialVariables.PSCommandPathVarPath, moduleManifestPath, true,
	CommandOrigin.Internal);
	ss.Internal.Module = manifestInfo;
	// without ModuleToProcess a manifest will export everything by default
	// (otherwise we want to honour exports from ModuleToProcess)
	if (exportedFunctions == null)
	{
	exportedFunctions = MatchAll;
	}
	if (exportedCmdlets == null)
	{
	exportedCmdlets = MatchAll;
	}
	if (exportedVariables == null)
	{
	exportedVariables = MatchAll;
	}
	if (exportedAliases == null)
	{
	exportedAliases = MatchAll;
	}
	if (exportedDscResources == null)
	{
	exportedDscResources = MatchAll;
	}
	}
	manifestInfo.Description = description;
	manifestInfo.PrivateData = privateData;
	manifestInfo.SetExportedTypeFiles(new ReadOnlyCollection<string>(exportedTypeFiles ?? new List<string>()));
	manifestInfo.SetExportedFormatFiles(new ReadOnlyCollection<string>(exportedFormatFiles ?? new List<string>()));
	manifestInfo.SetVersion(moduleVersion);
	manifestInfo.Author = author;
	manifestInfo.CompanyName = companyName;
	manifestInfo.Copyright = copyright;
	manifestInfo.DotNetFrameworkVersion = requestedDotNetFrameworkVersion;
	manifestInfo.ClrVersion = requestedClrVersion;
	manifestInfo.PowerShellHostName = requestedHostName;
	manifestInfo.PowerShellHostVersion = requestedHostVersion;
	manifestInfo.PowerShellVersion = powerShellVersion;
	manifestInfo.ProcessorArchitecture = requiredProcessorArchitecture;
	manifestInfo.Prefix = resolvedCommandPrefix;
	// A module is considered compatible if it's not on the System32 module path, or
	// if it is and declared "Core" as a compatible PSEdition.
	manifestInfo.IsConsideredEditionCompatible = isConsideredCompatible;
	if (expFeatureList != null)
	{
	manifestInfo.ExperimentalFeatures = new ReadOnlyCollection<ExperimentalFeature>(expFeatureList);
	}
	if (assemblyList != null)
	{
	foreach (var a in assemblyList)
	{
	manifestInfo.AddRequiredAssembly(a);
	}
	}
	if (fileList != null)
	{
	foreach (var f in fileList)
	{
	string absoluteFilePath = GetAbsolutePath(moduleBase, f);
	manifestInfo.AddToFileList(absoluteFilePath);
	}
	}
	if (moduleList != null)
	{
	foreach (var m in moduleList)
	{
	m.Name = GetAbsolutePath(moduleBase, m.Name);
	manifestInfo.AddToModuleList(m);
	}
	}
	if (compatiblePSEditions != null)
	{
	manifestInfo.AddToCompatiblePSEditions(compatiblePSEditions);
	}
	if (scriptsToProcess != null)
	{
	foreach (var s in scriptsToProcess)
	{
	manifestInfo.AddScript(s);
	}
	}
	manifestInfo.RootModule = actualRootModule;
	manifestInfo.RootModuleForManifest = actualRootModule;
	if (manifestGuid != null)
	{
	manifestInfo.SetGuid((Guid)manifestGuid);
	}
	if (helpInfoUri != null)
	{
	manifestInfo.SetHelpInfoUri(helpInfoUri);
	}
	foreach (PSModuleInfo module in requiredModulesLoaded)
	{
	manifestInfo.AddRequiredModule(module);
	}
	if (requiredModules != null)
	{
	foreach (ModuleSpecification moduleSpecification in requiredModules)
	{
	manifestInfo.AddRequiredModuleSpecification(moduleSpecification);
	}
	}
	// Populate the RepositorySourceLocation property from PSGetModuleInfo.xml file if it is available under the module base folder.
	var psgetItemInfoXml = Path.Combine(moduleBase, "PSGetModuleInfo.xml");
	if (File.Exists(psgetItemInfoXml))
	{
	WriteVerbose(StringUtil.Format(Modules.PopulatingRepositorySourceLocation, manifestInfo.Name));
	try
	{
	using (TextReader reader = File.OpenText(psgetItemInfoXml))
	{
	PSObject xml = PSSerializer.Deserialize(reader.ReadToEnd()) as PSObject;
	if (xml != null && xml.Properties["RepositorySourceLocation"] != null)
	{
	var repositorySourceLocation = xml.Properties["RepositorySourceLocation"].Value.ToString();
	Uri repositorySourceLocationUri;
	if (!string.IsNullOrWhiteSpace(repositorySourceLocation) &&
	Uri.TryCreate(repositorySourceLocation, UriKind.RelativeOrAbsolute,
	out repositorySourceLocationUri))
	{
	manifestInfo.RepositorySourceLocation = repositorySourceLocationUri;
	}
	}
	}
	}
	catch (UnauthorizedAccessException)
	{
	}
	catch (ArgumentException)
	{
	}
	catch (PathTooLongException)
	{
	}
	catch (NotSupportedException)
	{
	}
	catch (InvalidOperationException)
	{
	}
	catch (System.Xml.XmlException)
	{
	}
	}
	// If there are any wildcards, or any of the exported* are empty,
	// we need to do static analysis.
	if (!importingModule)
	{
	bool usedWildcard = false;
	bool sawExportedFunctions = false;
	bool sawExportedCmdlets = false;
	bool sawExportedAliases = false;
	if (exportedFunctions != null)
	{
	manifestInfo.DeclaredFunctionExports = new Collection<string>();
	if (exportedFunctions.Count > 0)
	{
	foreach (WildcardPattern p in exportedFunctions)
	{
	string name = p.Pattern;
	if (!WildcardPattern.ContainsWildcardCharacters(name))
	{
	manifestInfo.DeclaredFunctionExports.Add(AddPrefixToCommandName(name, defaultCommandPrefix));
	}
	else
	{
	usedWildcard = true;
	}
	}
	if (manifestInfo.DeclaredFunctionExports.Count == 0)
	{
	manifestInfo.DeclaredFunctionExports = null;
	}
	}
	sawExportedFunctions = true;
	}
	if (exportedCmdlets != null)
	{
	manifestInfo.DeclaredCmdletExports = new Collection<string>();
	if (exportedCmdlets.Count > 0)
	{
	foreach (WildcardPattern p in exportedCmdlets)
	{
	string name = p.Pattern;
	if (!WildcardPattern.ContainsWildcardCharacters(name))
	{
	manifestInfo.DeclaredCmdletExports.Add(AddPrefixToCommandName(name, defaultCommandPrefix));
	}
	else
	{
	usedWildcard = true;
	}
	}
	if (manifestInfo.DeclaredCmdletExports.Count == 0)
	{
	manifestInfo.DeclaredCmdletExports = null;
	}
	}
	sawExportedCmdlets = true;
	}
	if (exportedAliases != null)
	{
	manifestInfo.DeclaredAliasExports = new Collection<string>();
	if (exportedAliases.Count > 0)
	{
	foreach (WildcardPattern p in exportedAliases)
	{
	string name = p.Pattern;
	if (!WildcardPattern.ContainsWildcardCharacters(name))
	{
	manifestInfo.DeclaredAliasExports.Add(AddPrefixToCommandName(name, defaultCommandPrefix));
	}
	else
	{
	usedWildcard = true;
	}
	}
	if (manifestInfo.DeclaredAliasExports.Count == 0)
	{
	manifestInfo.DeclaredAliasExports = null;
	}
	}
	sawExportedAliases = true;
	}
	if (exportedVariables != null)
	{
	manifestInfo.DeclaredVariableExports = new Collection<string>();
	if (exportedVariables.Count > 0)
	{
	foreach (WildcardPattern p in exportedVariables)
	{
	string name = p.Pattern;
	if (!WildcardPattern.ContainsWildcardCharacters(name))
	{
	manifestInfo.DeclaredVariableExports.Add(name);
	}
	}
	if (manifestInfo.DeclaredVariableExports.Count == 0)
	{
	manifestInfo.DeclaredVariableExports = null;
	}
	}
	}
	// We have to further analyze the module if any wildcard characters are used.
	bool needToAnalyzeScriptModules = usedWildcard;
	// We can skip further analysis if 'FunctionsToExport', 'CmdletsToExport' and 'AliasesToExport'
	// are all declared and no wildcard character is used for them. But if any of 'FunctionsToExport',
	// 'CmdletsToExport' or 'AliasesToExport' were not given, we must check to see if more analysis is needed.
	if (!needToAnalyzeScriptModules && (!sawExportedCmdlets || !sawExportedFunctions || !sawExportedAliases))
	{
	foreach (var nestedModule in nestedModules)
	{
	if (AnalysisCache.ModuleAnalysisViaGetModuleRequired(
	nestedModule, sawExportedCmdlets, sawExportedFunctions, sawExportedAliases))
	{
	needToAnalyzeScriptModules = true;
	break;
	}
	}
	if (!needToAnalyzeScriptModules)
	{
	needToAnalyzeScriptModules = AnalysisCache.ModuleAnalysisViaGetModuleRequired(
	actualRootModule, sawExportedCmdlets, sawExportedFunctions, sawExportedAliases);
	}
	}
	bool etwEnabled = CommandDiscoveryEventSource.Log.IsEnabled();
	if (etwEnabled)
	{
	CommandDiscoveryEventSource.Log.ModuleManifestAnalysisResult(manifestInfo.Path, !needToAnalyzeScriptModules);
	}
	if (!needToAnalyzeScriptModules)
	{
	// Add nested modules to the manifestInfo when no more analysis needs to be done
	foreach (PSModuleInfo fakeNestedModuleInfo in CreateFakeModuleObject(nestedModules))
	{
	manifestInfo.AddNestedModule(fakeNestedModuleInfo);
	}
	return manifestInfo;
	}
	}
	if (scriptsToProcess != null)
	{
	Version savedBaseMinimumVersion = BaseMinimumVersion;
	Version savedBaseMaximumVersion = BaseMaximumVersion;
	Version savedBaseRequiredVersion = BaseRequiredVersion;
	Guid? savedBaseGuid = BaseGuid;
	try
	{
	BaseMinimumVersion = null;
	BaseMaximumVersion = null;
	BaseRequiredVersion = null;
	BaseGuid = null;
	foreach (string scriptFile in scriptsToProcess)
	{
	bool found = false;
	PSModuleInfo module = LoadModule(scriptFile,
	moduleBase,
	string.Empty, // prefix (-Prefix shouldn't be applied to dot sourced scripts)
	null,
	ref options,
	manifestProcessingFlags,
	out found);
	// If we're in analysis, add the detected exports to this module's
	// exports
	if (found && (ss == null))
	{
	foreach (string detectedCmdlet in module.ExportedCmdlets.Keys)
	{
	manifestInfo.AddDetectedCmdletExport(detectedCmdlet);
	}
	foreach (string detectedFunction in module.ExportedFunctions.Keys)
	{
	manifestInfo.AddDetectedFunctionExport(detectedFunction);
	}
	foreach (string detectedAlias in module.ExportedAliases.Keys)
	{
	manifestInfo.AddDetectedAliasExport(detectedAlias,
	module.ExportedAliases[detectedAlias].Definition);
	}
	}
	}
	}
	finally
	{
	BaseMinimumVersion = savedBaseMinimumVersion;
	BaseMaximumVersion = savedBaseMaximumVersion;
	BaseRequiredVersion = savedBaseRequiredVersion;
	BaseGuid = savedBaseGuid;
	}
	}
	// Process nested modules
	// If we have no session state and are loading a module, return an error
	if ((ss == null) && importingModule)
	{
	containedErrors = true;
	if (writingErrors)
	{
	string errorMessage =
	StringUtil.Format(Modules.ModuleManifestNestedModulesCantGoWithModuleToProcess,
	moduleManifestPath);
	ErrorRecord errorRecord = new ErrorRecord(
	new ArgumentException(errorMessage),
	"Modules_BinaryModuleAndNestedModules",
	ErrorCategory.InvalidArgument,
	moduleManifestPath);
	this.WriteError(errorRecord);
	}
	}
	// We have a session state, or are in module analysis
	// Save the various base cmdlet parameters so that we can import
	// all of the exported members from each nested module into this module...
	bool oldPassThru = BasePassThru;
	BasePassThru = false;
	List<WildcardPattern> oldVariablePatterns = BaseVariablePatterns;
	List<WildcardPattern> oldFunctionPatterns = BaseFunctionPatterns;
	List<WildcardPattern> oldAliasPatterns = BaseAliasPatterns;
	List<WildcardPattern> oldCmdletPatterns = BaseCmdletPatterns;
	BaseVariablePatterns = BaseFunctionPatterns = BaseAliasPatterns = BaseCmdletPatterns = MatchAll;
	bool oldBaseDisableNameChecking = BaseDisableNameChecking;
	BaseDisableNameChecking = true;
	SessionStateInternal oldSessionState = Context.EngineSessionState;
	var exportedFunctionsContainsWildcards = ModuleIntrinsics.PatternContainsWildcard(exportedFunctions);
	try
	{
	if (importingModule)
	{
	Dbg.Assert(ss != null, "ss should not be null");
	Dbg.Assert(ss.Internal != null, "ss.Internal should not be null");
	}
	if (ss != null)
	{
	ss.Internal.ManifestWithExplicitFunctionExport = !exportedFunctionsContainsWildcards;
	Context.EngineSessionState = ss.Internal;
	}
	// Load all of the nested modules, which may have relative or absolute paths...
	// For nested modules, we need to set importmoduleoptions to false as they should not use the options set for parent module
	ImportModuleOptions nestedModuleOptions = new ImportModuleOptions();
	// If the nested manifest explicitly (no wildcards) specifies functions to be exported then allow all functions to be exported
	// into the session state function table (regardless of language boundaries), because the manifest will filter them later to the
	// specified function list.
	nestedModuleOptions.AllowNestedModuleFunctionsToExport = ((exportedFunctions != null) && !exportedFunctionsContainsWildcards);
	foreach (ModuleSpecification nestedModuleSpecification in nestedModules)
	{
	bool found = false;
	// Never load nested modules to the global scope.
	bool oldGlobal = this.BaseGlobal;
	this.BaseGlobal = false;
	PSModuleInfo nestedModule = LoadModuleNamedInManifest(
	parentModule: manifestInfo,
	moduleSpecification: nestedModuleSpecification,
	moduleBase: moduleBase,
	searchModulePath: true,
	prefix: string.Empty,
	ss: null,
	options: nestedModuleOptions,
	manifestProcessingFlags: manifestProcessingFlags,
	loadTypes: true,
	loadFormats: true,
	privateData: privateData,
	found: out found,
	shortModuleName: null,
	manifestLanguageMode: ((manifestScriptInfo != null) ? manifestScriptInfo.DefiningLanguageMode.GetValueOrDefault() : (PSLanguageMode?)null));
	this.BaseGlobal = oldGlobal;
	// If found, add it to the parent's list of NestedModules
	if (found)
	{
	// If we're in analysis, add the detected exports to this module's
	// exports
	if ((ss == null) && (nestedModule != null))
	{
	foreach (string detectedCmdlet in nestedModule.ExportedCmdlets.Keys)
	{
	manifestInfo.AddDetectedCmdletExport(detectedCmdlet);
	}
	foreach (var detectedFunction in nestedModule.ExportedFunctions.Keys)
	{
	manifestInfo.AddDetectedFunctionExport(detectedFunction);
	}
	foreach (string detectedAlias in nestedModule.ExportedAliases.Keys)
	{
	manifestInfo.AddDetectedAliasExport(detectedAlias,
	nestedModule.ExportedAliases[detectedAlias].Definition);
	}
	}
	// If the NestedModules was a .ps1 script no module object would have been generated
	// so there's nothing to add, otherwise add it to the list.
	// When we are in analysis mode and we do not analyze the nested module (because the parent module has explicit exports), the nested modules do not get added to the list
	if (nestedModule != null)
	{
	manifestInfo.AddNestedModule(nestedModule);
	}
	}
	else
	{
	containedErrors = true;
	string errorMessage = StringUtil.Format(Modules.ManifestMemberNotFound,
	nestedModuleSpecification.Name, "NestedModules", moduleManifestPath);
	FileNotFoundException fnf = new FileNotFoundException(errorMessage);
	PSInvalidOperationException invalidOperation = new PSInvalidOperationException(
	errorMessage, fnf, "Modules_ModuleFileNotFound", ErrorCategory.ResourceUnavailable,
	ModuleIntrinsics.GetModuleName(moduleManifestPath));
	throw invalidOperation;
	}
	}
	}
	catch (Exception)
	{
	// Remove the types and format files
	this.RemoveTypesAndFormatting(exportedFormatFiles, exportedTypeFiles);
	throw;
	}
	finally
	{
	// Restore the old session state object...
	Context.EngineSessionState = oldSessionState;
	// Restore the various cmdlet parameters to what the user passed in...
	BasePassThru = oldPassThru;
	BaseVariablePatterns = oldVariablePatterns;
	BaseFunctionPatterns = oldFunctionPatterns;
	BaseAliasPatterns = oldAliasPatterns;
	BaseCmdletPatterns = oldCmdletPatterns;
	BaseDisableNameChecking = oldBaseDisableNameChecking;
	}
	// Now see if the ModuleToProcess field was set. This radically
	// changes how the exports are done.
	if (actualRootModule != null)
	{
	PSModuleInfo newManifestInfo;
	// do not write out ModuleToProcess inside LoadModuleNamedInManifest
	// - wait until all attributes have been taken from psd1 into PSModuleInfo/manifestInfo
	// and then write out manifestInfo
	BasePassThru = false;
	// do not import anything from "ModuleToProcess" at this time
	// below we will call ImportModuleMembers(manifestInfo) after all nested modules have been processed
	BaseVariablePatterns = new List<WildcardPattern>();
	BaseFunctionPatterns = new List<WildcardPattern>();
	BaseAliasPatterns = new List<WildcardPattern>();
	BaseCmdletPatterns = new List<WildcardPattern>();
	try
	{
	bool found;
	newManifestInfo = LoadModuleNamedInManifest(
	parentModule: null,
	moduleSpecification: new ModuleSpecification(actualRootModule),
	moduleBase: moduleBase,
	searchModulePath: false,
	prefix: resolvedCommandPrefix,
	ss: ss,
	options: options,
	manifestProcessingFlags: manifestProcessingFlags,
	loadTypes: (exportedTypeFiles == null || exportedTypeFiles.Count == 0), // If types files already loaded, don't load snapin files
	loadFormats: (exportedFormatFiles == null || exportedFormatFiles.Count == 0), // if format files already loaded, don't load snapin files
	privateData: privateData,
	found: out found,
	shortModuleName: null,
	manifestLanguageMode: ((manifestScriptInfo != null) ? manifestScriptInfo.DefiningLanguageMode.GetValueOrDefault() : (PSLanguageMode?)null));
	if (!found || (newManifestInfo == null))
	{
	containedErrors = true;
	string errorMessage = StringUtil.Format(Modules.ManifestMemberNotFound, actualRootModule,
	"ModuleToProcess/RootModule", moduleManifestPath);
	FileNotFoundException fnf = new FileNotFoundException(errorMessage);
	PSInvalidOperationException invalidOperation = new PSInvalidOperationException(errorMessage, fnf,
	"Modules_ModuleFileNotFound", ErrorCategory.ResourceUnavailable,
	ModuleIntrinsics.GetModuleName(moduleManifestPath));
	throw invalidOperation;
	}
	ErrorRecord errorRecord = GetErrorRecordIfUnsupportedRootCdxmlAndNestedModuleScenario(data,
	moduleManifestPath, newManifestInfo.Path);
	if (errorRecord != null)
	{
	containedErrors = true;
	RemoveModule(newManifestInfo);
	PSInvalidOperationException invalidOperation =
	new PSInvalidOperationException(errorRecord.Exception.Message, errorRecord.Exception,
	errorRecord.FullyQualifiedErrorId, ErrorCategory.InvalidOperation, moduleManifestPath);
	throw invalidOperation;
	}
	}
	catch (Exception)
	{
	// Remove the types and format files
	this.RemoveTypesAndFormatting(exportedFormatFiles, exportedTypeFiles);
	throw;
	}
	finally
	{
	// Restore the various cmdlet parameters to what the user passed in...
	BasePassThru = oldPassThru;
	BaseVariablePatterns = oldVariablePatterns;
	BaseFunctionPatterns = oldFunctionPatterns;
	BaseAliasPatterns = oldAliasPatterns;
	BaseCmdletPatterns = oldCmdletPatterns;
	}
	// For most cases, 'newManifestInfo.SessionState' should be identical to 'ss':
	// 1. when 'importingModule == true', 'newManifestInfo' uses the same session state as 'ss' because we passed in 'ss' when loading the RootModule via 'LoadModuleNamedInManifest'.
	// 2. when 'importingModule == false', both session states will be null since we are in module analysis mode (Get-Module -ListAvailable).
	//
	// However, there is one exception when the RootModule is also put in NestedModules in the module manifest (ill-organized module structure).
	// For example, module folder 'test' contains two files: 'test.psd1' and 'test.psm1', and 'test.psd1' has the following content:
	// "@{ ModuleVersion = '0.0.1'; RootModule = 'test'; NestedModules = @('test') }"
	//
	// In that case, the nested module will first be loaded with a different session state, and then when trying to load the RootModule via 'LoadModuleNamedInManifest',
	// the same loaded nested module will be reused for the RootModule by 'LoadModuleNamedInManifest'.
	// Change the module name to match the manifest name, not the original name.
	newManifestInfo.SetName(manifestInfo.Name);
	// Copy in any nested modules...
	foreach (PSModuleInfo nm in manifestInfo.NestedModules)
	{
	newManifestInfo.AddNestedModule(nm);
	}
	// Copy the required modules...
	foreach (PSModuleInfo rm in manifestInfo.RequiredModules)
	{
	newManifestInfo.AddRequiredModule(rm);
	}
	// Copy in the version number - this over-write anything extracted
	// from the dll in the case of a binary module
	newManifestInfo.SetVersion(manifestInfo.Version);
	// Set the various bits of metadata from the manifest
	if (string.IsNullOrEmpty(newManifestInfo.Description))
	{
	newManifestInfo.Description = description;
	}
	if (newManifestInfo.Version.Equals(new Version(0, 0)))
	{
	newManifestInfo.SetVersion(moduleVersion);
	}
	if (newManifestInfo.Guid.Equals(Guid.Empty) && (manifestGuid != null))
	{
	newManifestInfo.SetGuid((Guid)manifestGuid);
	}
	if (newManifestInfo.HelpInfoUri == null && (helpInfoUri != null))
	{
	newManifestInfo.SetHelpInfoUri(helpInfoUri);
	}
	if (requiredModules != null)
	{
	foreach (ModuleSpecification moduleSpecification in requiredModules)
	{
	newManifestInfo.AddRequiredModuleSpecification(moduleSpecification);
	}
	}
	if (newManifestInfo.RootModule == null)
	{
	newManifestInfo.RootModule = manifestInfo.RootModule;
	}
	// If may be the case that a script has already set the PrivateData field in the module
	// info object, in which case we won't overwrite it.
	if (newManifestInfo.PrivateData == null)
	{
	newManifestInfo.PrivateData = manifestInfo.PrivateData;
	}
	// Assign the PowerShellGet related properties from the module manifest
	foreach (var tag in manifestInfo.Tags)
	{
	newManifestInfo.AddToTags(tag);
	}
	newManifestInfo.ReleaseNotes = manifestInfo.ReleaseNotes;
	newManifestInfo.ProjectUri = manifestInfo.ProjectUri;
	newManifestInfo.LicenseUri = manifestInfo.LicenseUri;
	newManifestInfo.IconUri = manifestInfo.IconUri;
	newManifestInfo.RepositorySourceLocation = manifestInfo.RepositorySourceLocation;
	newManifestInfo.IsConsideredEditionCompatible = manifestInfo.IsConsideredEditionCompatible;
	newManifestInfo.ExperimentalFeatures = manifestInfo.ExperimentalFeatures;
	// If we are in module discovery, then fix the path.
	if (ss == null)
	{
	newManifestInfo.Path = manifestInfo.Path;
	}
	if (string.IsNullOrEmpty(newManifestInfo.Author))
	{
	newManifestInfo.Author = author;
	}
	if (string.IsNullOrEmpty(newManifestInfo.CompanyName))
	{
	newManifestInfo.CompanyName = companyName;
	}
	if (string.IsNullOrEmpty(newManifestInfo.Copyright))
	{
	newManifestInfo.Copyright = copyright;
	}
	if (newManifestInfo.PowerShellVersion == null)
	{
	newManifestInfo.PowerShellVersion = powerShellVersion;
	}
	if (string.IsNullOrEmpty(newManifestInfo.PowerShellHostName))
	{
	newManifestInfo.PowerShellHostName = requestedHostName;
	}
	if (newManifestInfo.PowerShellHostVersion == null)
	{
	newManifestInfo.PowerShellHostVersion = requestedHostVersion;
	}
	if (newManifestInfo.DotNetFrameworkVersion == null)
	{
	newManifestInfo.DotNetFrameworkVersion = requestedDotNetFrameworkVersion;
	}
	if (newManifestInfo.ClrVersion == null)
	{
	newManifestInfo.ClrVersion = requestedClrVersion;
	}
	if (string.IsNullOrEmpty(newManifestInfo.Prefix))
	{
	newManifestInfo.Prefix = resolvedCommandPrefix;
	}
	if (newManifestInfo.FileList == null || !newManifestInfo.FileList.Any())
	{
	if (fileList != null)
	{
	foreach (var f in fileList)
	{
	newManifestInfo.AddToFileList(f);
	}
	}
	}
	if (newManifestInfo.ModuleList == null || !newManifestInfo.ModuleList.Any())
	{
	if (moduleList != null)
	{
	foreach (var m in moduleList)
	{
	newManifestInfo.AddToModuleList(m);
	}
	}
	}
	if (newManifestInfo.CompatiblePSEditions == null || !newManifestInfo.CompatiblePSEditions.Any())
	{
	if (compatiblePSEditions != null)
	{
	newManifestInfo.AddToCompatiblePSEditions(compatiblePSEditions);
	}
	}
	if (newManifestInfo.ProcessorArchitecture == ProcessorArchitecture.None)
	{
	newManifestInfo.ProcessorArchitecture = requiredProcessorArchitecture;
	}
	if (newManifestInfo.RequiredAssemblies == null || !newManifestInfo.RequiredAssemblies.Any())
	{
	if (assemblyList != null)
	{
	foreach (var a in assemblyList)
	{
	newManifestInfo.AddRequiredAssembly(a);
	}
	}
	}
	if (newManifestInfo.Scripts == null || !newManifestInfo.Scripts.Any())
	{
	if (scriptsToProcess != null)
	{
	foreach (var s in scriptsToProcess)
	{
	newManifestInfo.AddScript(s);
	}
	}
	}
	if (newManifestInfo.RootModuleForManifest == null)
	{
	newManifestInfo.RootModuleForManifest = manifestInfo.RootModuleForManifest;
	}
	if (newManifestInfo.DeclaredCmdletExports == null || newManifestInfo.DeclaredCmdletExports.Count == 0)
	{
	newManifestInfo.DeclaredCmdletExports = manifestInfo.DeclaredCmdletExports;
	}
	if (manifestInfo.DetectedCmdletExports != null)
	{
	foreach (string detectedExport in manifestInfo.DetectedCmdletExports)
	{
	newManifestInfo.AddDetectedCmdletExport(detectedExport);
	}
	}
	if (newManifestInfo.DeclaredFunctionExports == null ||
	newManifestInfo.DeclaredFunctionExports.Count == 0)
	{
	newManifestInfo.DeclaredFunctionExports = manifestInfo.DeclaredFunctionExports;
	}
	if (manifestInfo.DetectedFunctionExports != null)
	{
	foreach (string detectedExport in manifestInfo.DetectedFunctionExports)
	{
	newManifestInfo.AddDetectedFunctionExport(detectedExport);
	}
	}
	if (newManifestInfo.DeclaredAliasExports == null || newManifestInfo.DeclaredAliasExports.Count == 0)
	{
	newManifestInfo.DeclaredAliasExports = manifestInfo.DeclaredAliasExports;
	}
	if (manifestInfo.DetectedAliasExports != null)
	{
	foreach (var pair in manifestInfo.DetectedAliasExports)
	{
	newManifestInfo.AddDetectedAliasExport(pair.Key, pair.Value);
	}
	}
	if (newManifestInfo.DeclaredVariableExports == null ||
	newManifestInfo.DeclaredVariableExports.Count == 0)
	{
	newManifestInfo.DeclaredVariableExports = manifestInfo.DeclaredVariableExports;
	}
	// If there are types/formats entries in the ModuleToProcess use them
	// only if there are no entries from the manifest. The manifest entries
	// completely override the module's entries.
	if (manifestInfo.ExportedTypeFiles.Count > 0)
	{
	newManifestInfo.SetExportedTypeFiles(manifestInfo.ExportedTypeFiles);
	}
	if (manifestInfo.ExportedFormatFiles.Count > 0)
	{
	newManifestInfo.SetExportedFormatFiles(manifestInfo.ExportedFormatFiles);
	}
	// And switch to using the new manifest info
	manifestInfo = newManifestInfo;
	// mark the binary module exports...
	if (manifestInfo.ModuleType == ModuleType.Binary)
	{
	if ((exportedCmdlets != null) && (ss != null))
	{
	manifestInfo.ExportedCmdlets.Clear();
	// Mark stuff for export
	if (ss != null)
	{
	ModuleIntrinsics.ExportModuleMembers(
	this,
	ss.Internal,
	exportedFunctions,
	exportedCmdlets,
	exportedAliases,
	exportedVariables,
	doNotExportCmdlets: null);
	}
	}
	}
	else
	{
	// If the script didn't call Export-ModuleMember explicitly, then
	// implicitly export functions and cmdlets.
	if ((ss != null) && (!ss.Internal.UseExportList))
	{
	// For cross language boundaries, implicitly import all functions only if
	// this manifest *does* exort functions explicitly.
	List<WildcardPattern> fnMatchPattern = (
	(manifestScriptInfo.DefiningLanguageMode == PSLanguageMode.FullLanguage) &&
	(Context.LanguageMode != PSLanguageMode.FullLanguage) &&
	(exportedFunctions == null)
	) ? null : MatchAll;
	ModuleIntrinsics.ExportModuleMembers(cmdlet: this,
	sessionState: ss.Internal,
	functionPatterns: fnMatchPattern,
	cmdletPatterns: MatchAll,
	aliasPatterns: null,
	variablePatterns: null,
	doNotExportCmdlets: null);
	}
	// Export* fields in .psd1 subset Export-ModuleMember calls from ModuleToProcess=psm1
	if (exportedFunctions != null)
	{
	if (ss != null)
	{
	// If module (psm1) functions were not exported because of cross language boundary restrictions,
	// then implicitly export them here so that they can be filtered by the exportedFunctions list.
	// Unless exportedFunctions contains the wildcard character that isn't allowed across language
	// boundaries.
	if (!ss.Internal.FunctionsExported && !exportedFunctionsContainsWildcards)
	{
	ModuleIntrinsics.ExportModuleMembers(
	cmdlet: this,
	sessionState: ss.Internal,
	functionPatterns: MatchAll,
	cmdletPatterns: null,
	aliasPatterns: null,
	variablePatterns: null,
	doNotExportCmdlets: null);
	}
	Dbg.Assert(ss.Internal.ExportedFunctions != null,
	"ss.Internal.ExportedFunctions should not be null");
	// Update the exports to only contain things that are also in the manifest export list
	UpdateCommandCollection<FunctionInfo>(ss.Internal.ExportedFunctions, exportedFunctions);
	}
	else
	{
	UpdateCommandCollection(manifestInfo.DeclaredFunctionExports, exportedFunctions);
	}
	}
	if (exportedCmdlets != null)
	{
	if (ss != null)
	{
	Dbg.Assert(ss.Internal.ExportedCmdlets != null,
	"ss.Internal.ExportedCmdlets should not be null");
	// Update the exports to only contain things that are also in the manifest export list
	UpdateCommandCollection<CmdletInfo>(manifestInfo.CompiledExports, exportedCmdlets);
	}
	else
	{
	UpdateCommandCollection(manifestInfo.DeclaredCmdletExports, exportedCmdlets);
	}
	}
	if (exportedAliases != null)
	{
	if (ss != null)
	{
	Dbg.Assert(ss.Internal.ExportedAliases != null,
	"ss.Internal.ExportedAliases should not be null");
	// Update the exports to only contain things that are also in the manifest export list
	UpdateCommandCollection<AliasInfo>(ss.Internal.ExportedAliases, exportedAliases);
	}
	else
	{
	UpdateCommandCollection(manifestInfo.DeclaredAliasExports, exportedAliases);
	}
	}
	if (exportedVariables != null)
	{
	if (ss != null)
	{
	Dbg.Assert(ss.Internal.ExportedVariables != null,
	"ss.Internal.ExportedVariables should not be null");
	// Update the exports to only contain things that are also in the manifest export list
	List<PSVariable> updated = new List<PSVariable>();
	foreach (PSVariable element in ss.Internal.ExportedVariables)
	{
	if (SessionStateUtilities.MatchesAnyWildcardPattern(
	element.Name,
	exportedVariables,
	defaultValue: false))
	{
	updated.Add(element);
	}
	}
	ss.Internal.ExportedVariables.Clear();
	ss.Internal.ExportedVariables.AddRange(updated);
	}
	}
	}
	}
	else
	{
	if (ss != null)
	{
	// In the case where there are only nested modules,
	// the members of the manifest are canonical...
	ModuleIntrinsics.ExportModuleMembers(
	this,
	sessionState: ss.Internal,
	functionPatterns: exportedFunctions,
	cmdletPatterns: exportedCmdlets,
	aliasPatterns: exportedAliases,
	variablePatterns: exportedVariables,
	doNotExportCmdlets: null);
	}
	}
	PropagateExportedTypesFromNestedModulesToRootModuleScope(options, manifestInfo);
	SetDeclaredDscResources(exportedDscResources, manifestInfo);
	// And import the members from this module into the callers context...
	if (importingModule)
	{
	ImportModuleMembers(manifestInfo, resolvedCommandPrefix, options);
	}
	manifestInfo.LanguageMode = (manifestScriptInfo != null) ? manifestScriptInfo.DefiningLanguageMode : (PSLanguageMode?)null;
	return manifestInfo;
	}

I would like for us to refactor that method to enable a number of scenarios, but the module code is sensitive and services a lot of different cases, so that's currently blocked on improving testing of module scenarios. Also it hasn't been prioritised.

[iSazonov]

I would like for us to refactor that method to enable a number of scenarios, but the module code is sensitive and services a lot of different cases, so that's currently blocked on improving testing of module scenarios. Also it hasn't been prioritised.

I think today is good time to re-think and re-design the area.
Short thoughts:

1. Allow new keywords in psd1 files for new features (PrivateData is ugly)
2. Duplicate its in PrivateData section for Windows PowerShell if needed.
3. For Windows PowerShell create a simple servicing fix to pass such manifest check

This open ways for future improvements and enhancements.

[rjmholt]

Allow new keywords in psd1 files for new features (PrivateData is ugly)

Yeah I'd like to do this too. We can't change old versions, but it would be nice to be tolerant as we move forward.

Duplicate its in PrivateData section for Windows PowerShell if needed.

Don't quite understand you here. Do you mean that we should continue to support the PrivateData field for backward compatibility? If so, I agree.

For Windows PowerShell create a simple servicing fix to pass such manifest check

This one I'm not sure we can do. To be clear I have no control over that, but I think one of the major issues is that it would mark a significant change in behaviour in what's supposed to be a stable product version. Explaining to people that their module does or doesn't load because of a Windows patch would be a nightmare (we already see things like that and it's certainly hard to debug and often harder to explain).

[iSazonov]

Don't quite understand you here. Do you mean that we should continue to support the PrivateData field for backward compatibility? If so, I agree.

Yes, if a module is only for PowerShell Core we have no need to add the section, but if a developer want to make its module compatible with WinPS one should add PrivateData section and WinPS should silently skip new PowerShell Core keywords out of PrivateData section.

This one I'm not sure we can do.

It would be minor compatibility fix. I hope MSFT team can approve this.

[rjmholt]

It would be minor compatibility fix.

I think it would represent a fairly significant behaviour change

[iSazonov]

I think it would represent a fairly significant behaviour change

Why? We need only skip new keyword(s) in psd1, no new behavior will be added.