Check structuralIsReused with switch statement

Returning `true` when `structuralIsReused === undefined` is a bit
unexpected, but matches the existing behavior of the program. Changing
it to `false` breaks the following test:

  1) unittests:: Reuse program structure:: General
       can reuse ambient module declarations from non-modified files:

      should reuse 'fs' since node.d.ts was not changed
      + expected - actual

Author: gluxon

src/compiler/program.ts

@@ -1107,7 +1107,7 @@ namespace ts {
         }
 
         function resolveModuleNamesReusingOldState(moduleNames: string[], file: SourceFile): readonly ResolvedModuleFull[] {
-            if (structuralIsReused === StructureIsReused.Not && !file.ambientModuleNames.length) {
+            if (!doesStructuralPermitResolutionsReuse() && !file.ambientModuleNames.length) {
                 // If the old program state does not permit reusing resolutions and `file` does not contain locally defined ambient modules,
                 // the best we can do is fallback to the default logic.
                 return resolveModuleNamesWorker(moduleNames, file, /*reusedNames*/ undefined);
@@ -1218,6 +1218,28 @@ namespace ts {
 
             return result;
 
+            function doesStructuralPermitResolutionsReuse(): boolean {
+                switch (structuralIsReused) {
+                    case StructureIsReused.Not: return false;
+                    case StructureIsReused.SafeModules: return true;
+                    case StructureIsReused.Completely: return true;
+
+                    // It's possible for resolveModuleNamesReusingOldState to be called by
+                    // tryReuseStructureFromOldProgram before structuralIsReused has been defined.
+                    // In this case, the caller (tryReuseStructureFromOldProgram) expects this
+                    // function to reuse resolutions for its checks. Returning true to accommodate
+                    // for that specific scenario.
+                    //
+                    // TODO: Clean this because the above scenario is a bit unexpected. This case
+                    // should ideally return false or throw.
+                    case undefined: return true;
+
+                    // The above cases should exhaustively cover all branches. Defaulting to false
+                    // since that's safer in unexpected situations.
+                    default: return false;
+                }
+            }
+
             // If we change our policy of rechecking failed lookups on each program create,
             // we should adjust the value returned here.
             function moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName: string): boolean {