Refactor and add tasks to acquire xaml dependencies

Author: dibarbet

package.json

@@ -41,7 +41,8 @@
     "omniSharp": "1.39.11",
     "razor": "7.0.0-preview.24178.4",
     "razorOmnisharp": "7.0.0-preview.23363.1",
-    "razorTelemetry": "7.0.0-preview.24178.4"
+    "razorTelemetry": "7.0.0-preview.24178.4",
+    "xamlDesignTools": "17.11.34810.23"
   },
   "main": "./dist/extension",
   "l10n": "./l10n",

tasks/offlinePackagingTasks.ts

@@ -24,6 +24,7 @@ import {
     nugetTempPath,
     rootPath,
     devKitDependenciesDirectory,
+    xamlDesignToolsDirectory,
 } from '../tasks/projectPaths';
 import { getPackageJSON } from '../tasks/packageJson';
 import { createPackageAsync } from '../tasks/vsceTasks';
@@ -56,6 +57,35 @@ export const platformSpecificPackages: VSIXPlatformInfo[] = [
     { vsceTarget: 'darwin-arm64', rid: 'osx-arm64', platformInfo: new PlatformInformation('darwin', 'arm64') },
 ];
 
+interface NugetPackageInfo {
+    getPackageName: (platformInfo: VSIXPlatformInfo | undefined) => string;
+    packageJsonName: string;
+    getPackageContentPath: (platformInfo: VSIXPlatformInfo | undefined) => string;
+    vsixOutputPath: string;
+}
+
+// Set of NuGet packages that we need to download and install.
+export const nugetPackageInfo: { [key: string]: NugetPackageInfo } = {
+    roslyn: {
+        getPackageName: (platformInfo) => `Microsoft.CodeAnalysis.LanguageServer.${platformInfo?.rid ?? 'neutral'}`,
+        packageJsonName: 'roslyn',
+        getPackageContentPath: (platformInfo) => path.join('content', 'LanguageServer', platformInfo?.rid ?? 'neutral'),
+        vsixOutputPath: languageServerDirectory,
+    },
+    roslynDevKit: {
+        getPackageName: (_platformInfo) => 'Microsoft.VisualStudio.LanguageServices.DevKit',
+        packageJsonName: 'roslyn',
+        getPackageContentPath: (_platformInfo) => 'content',
+        vsixOutputPath: devKitDependenciesDirectory,
+    },
+    xamlDesignTools: {
+        getPackageName: (_platformInfo) => 'Microsoft.VisualStudio.DesignToolsBase',
+        packageJsonName: 'xamlDesignTools',
+        getPackageContentPath: (_platformInfo) => '',
+        vsixOutputPath: xamlDesignToolsDirectory,
+    },
+};
+
 const vsixTasks: string[] = [];
 for (const p of platformSpecificPackages) {
     let platformName: string;
@@ -100,11 +130,12 @@ gulp.task('installDependencies', async () => {
     const packageJSON = getPackageJSON();
 
     const platform = await PlatformInformation.GetCurrent();
+    const vsixPlatformInfo = platformSpecificPackages.find(
+        (p) => p.platformInfo.platform === platform.platform && p.platformInfo.architecture === platform.architecture
+    )!;
 
     try {
-        await installRoslyn(packageJSON, platform);
-        await installDebugger(packageJSON, platform);
-        await installRazor(packageJSON, platform);
+        acquireAndInstallAllNugetPackages(vsixPlatformInfo, packageJSON, true);
     } catch (err) {
         const message = (err instanceof Error ? err.stack : err) ?? '<unknown error>';
         // NOTE: Extra `\n---` at the end is because gulp will print this message following by the
@@ -113,52 +144,75 @@ gulp.task('installDependencies', async () => {
     }
 });
 
+// Defines a special task to acquire all the platform specific Roslyn packages.
+// All packages need to be saved to the consumption AzDo artifacts feed, for non-platform
+// specific packages this only requires running the installDependencies tasks.  However for Roslyn packages
+// we need to acquire the nuget packages once for each platform to ensure they get saved to the feed.
 gulp.task(
     'updateRoslynVersion',
     // Run the fetch of all packages, and then also installDependencies after
     gulp.series(async () => {
         const packageJSON = getPackageJSON();
 
         // Fetch the neutral package that we don't otherwise have in our platform list
-        await acquireRoslyn(packageJSON, undefined, true);
+        await acquireNugetPackage(nugetPackageInfo.roslyn, undefined, packageJSON, true);
 
         // And now fetch each platform specific
         for (const p of platformSpecificPackages) {
-            await acquireRoslyn(packageJSON, p.platformInfo, true);
+            await acquireNugetPackage(nugetPackageInfo.roslyn, p, packageJSON, true);
         }
 
         // Also pull in the Roslyn DevKit dependencies nuget package.
-        await acquireRoslynDevKit(packageJSON, true);
+        await acquireNugetPackage(nugetPackageInfo.RoslynDevKit, undefined, packageJSON, true);
     }, 'installDependencies')
 );
 
-// Install Tasks
-async function installRoslyn(packageJSON: any, platformInfo?: PlatformInformation) {
-    // Install the Roslyn language server bits.
-    const { packagePath, serverPlatform } = await acquireRoslyn(packageJSON, platformInfo, false);
-    await installNuGetPackage(
-        packagePath,
-        path.join('content', 'LanguageServer', serverPlatform),
-        languageServerDirectory
-    );
+async function acquireAndInstallAllNugetPackages(
+    platformInfo: VSIXPlatformInfo | undefined,
+    packageJSON: any,
+    interactive: boolean
+) {
+    for (const key in nugetPackageInfo) {
+        const nugetPackage = nugetPackageInfo[key];
+        const packagePath = await acquireNugetPackage(nugetPackage, platformInfo, packageJSON, interactive);
+        await installNuGetPackage(packagePath, nugetPackage, platformInfo);
+    }
+}
 
-    // Install Roslyn DevKit dependencies.
-    const roslynDevKitPackagePath = await acquireRoslynDevKit(packageJSON, false);
-    await installNuGetPackage(roslynDevKitPackagePath, 'content', devKitDependenciesDirectory);
+async function acquireNugetPackage(
+    nugetPackageInfo: NugetPackageInfo,
+    platformInfo: VSIXPlatformInfo | undefined,
+    packageJSON: any,
+    interactive: boolean
+) {
+    const packageVersion = packageJSON.defaults[nugetPackageInfo.packageJsonName];
+    const packageName = nugetPackageInfo.getPackageName(platformInfo);
+    const packagePath = await restoreNugetPackage(packageName, packageVersion, interactive);
+    return packagePath;
 }
 
-async function installNuGetPackage(pathToPackage: string, contentPath: string, outputPath: string) {
+async function installNuGetPackage(
+    pathToPackage: string,
+    nugetPackageInfo: NugetPackageInfo,
+    platformInfo: VSIXPlatformInfo | undefined
+) {
     // Get the directory containing the content.
-    const contentDirectory = path.join(pathToPackage, contentPath);
+    const pathToContentInNugetPackage = nugetPackageInfo.getPackageContentPath(platformInfo);
+    const contentDirectory = path.join(pathToPackage, pathToContentInNugetPackage);
     if (!fs.existsSync(contentDirectory)) {
-        throw new Error(`Failed to find NuGet package content at ${contentDirectory}`);
+        throw new Error(
+            `Failed to find NuGet package content at ${contentDirectory} for ${nugetPackageInfo.getPackageName(
+                platformInfo
+            )}`
+        );
     }
 
     const numFilesToCopy = fs.readdirSync(contentDirectory).length;
 
     console.log(`Extracting content from ${contentDirectory}`);
 
-    // Copy the files to the language server directory.
+    // Copy the files to the specified output directory.
+    const outputPath = nugetPackageInfo.vsixOutputPath;
     fs.mkdirSync(outputPath);
     fsextra.copySync(contentDirectory, outputPath);
     const numCopiedFiles = fs.readdirSync(outputPath).length;
@@ -169,43 +223,6 @@ async function installNuGetPackage(pathToPackage: string, contentPath: string, o
     }
 }
 
-async function acquireRoslyn(
-    packageJSON: any,
-    platformInfo: PlatformInformation | undefined,
-    interactive: boolean
-): Promise<{ packagePath: string; serverPlatform: string }> {
-    const roslynVersion = packageJSON.defaults.roslyn;
-
-    // Find the matching server RID for the current platform.
-    let serverPlatform: string;
-    if (platformInfo === undefined) {
-        serverPlatform = 'neutral';
-    } else {
-        serverPlatform = platformSpecificPackages.find(
-            (p) =>
-                p.platformInfo.platform === platformInfo.platform &&
-                p.platformInfo.architecture === platformInfo.architecture
-        )!.rid;
-    }
-
-    const packagePath = await acquireNugetPackage(
-        `Microsoft.CodeAnalysis.LanguageServer.${serverPlatform}`,
-        roslynVersion,
-        interactive
-    );
-    return { packagePath, serverPlatform };
-}
-
-async function acquireRoslynDevKit(packageJSON: any, interactive: boolean): Promise<string> {
-    const roslynVersion = packageJSON.defaults.roslyn;
-    const packagePath = await acquireNugetPackage(
-        `Microsoft.VisualStudio.LanguageServices.DevKit`,
-        roslynVersion,
-        interactive
-    );
-    return packagePath;
-}
-
 async function installRazor(packageJSON: any, platformInfo: PlatformInformation) {
     if (platformInfo === undefined) {
         const platformNeutral = new PlatformInformation('neutral', 'neutral');
@@ -243,7 +260,7 @@ async function installPackageJsonDependency(
     }
 }
 
-async function acquireNugetPackage(packageName: string, packageVersion: string, interactive: boolean): Promise<string> {
+async function restoreNugetPackage(packageName: string, packageVersion: string, interactive: boolean): Promise<string> {
     packageName = packageName.toLocaleLowerCase();
     const packageOutputPath = path.join(nugetTempPath, packageName, packageVersion);
     if (fs.existsSync(packageOutputPath)) {
@@ -310,13 +327,7 @@ async function doPackageOffline(vsixPlatform: VSIXPlatformInfo | undefined) {
         if (vsixPlatform === undefined) {
             await buildVsix(packageJSON, packedVsixOutputRoot, prerelease);
         } else {
-            await buildVsix(
-                packageJSON,
-                packedVsixOutputRoot,
-                prerelease,
-                vsixPlatform.vsceTarget,
-                vsixPlatform.platformInfo
-            );
+            await buildVsix(packageJSON, packedVsixOutputRoot, prerelease, vsixPlatform);
         }
     } catch (err) {
         const message = (err instanceof Error ? err.stack : err) ?? '<unknown error>';
@@ -340,22 +351,16 @@ async function cleanAsync() {
     ]);
 }
 
-async function buildVsix(
-    packageJSON: any,
-    outputFolder: string,
-    prerelease: boolean,
-    vsceTarget?: string,
-    platformInfo?: PlatformInformation
-) {
-    await installRoslyn(packageJSON, platformInfo);
+async function buildVsix(packageJSON: any, outputFolder: string, prerelease: boolean, platformInfo?: VSIXPlatformInfo) {
+    await acquireAndInstallAllNugetPackages(platformInfo, packageJSON, false);
 
     if (platformInfo != null) {
-        await installRazor(packageJSON, platformInfo);
-        await installDebugger(packageJSON, platformInfo);
+        await installRazor(packageJSON, platformInfo.platformInfo);
+        await installDebugger(packageJSON, platformInfo.platformInfo);
     }
 
-    const packageFileName = getPackageName(packageJSON, vsceTarget);
-    await createPackageAsync(outputFolder, prerelease, packageFileName, vsceTarget);
+    const packageFileName = getPackageName(packageJSON, platformInfo?.vsceTarget);
+    await createPackageAsync(outputFolder, prerelease, packageFileName, platformInfo?.vsceTarget);
 }
 
 function getPackageName(packageJSON: any, vscodePlatformId?: string) {

tasks/projectPaths.ts

@@ -16,6 +16,7 @@ export const packedVsixOutputRoot = commandLineOptions.outputFolder || path.join
 export const nugetTempPath = path.join(rootPath, 'out', '.nuget');
 export const languageServerDirectory = path.join(rootPath, '.roslyn');
 export const devKitDependenciesDirectory = path.join(rootPath, '.roslynDevKit');
+export const xamlDesignToolsDirectory = path.join(rootPath, '.xamlDesignTools');
 
 export const codeExtensionPath = commandLineOptions.codeExtensionPath || rootPath;