feat(tsconfig): complete inheritance of compilerOptions fields (#657)

Some `compilerOptions` fields were added without implementing the corresponding inheritance logic.

Author: shulaoda

fixtures/tsconfig/cases/extends-base-url/base-tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "baseUrl": "./src",
+    "emitDecoratorMetadata": true,
+    "useDefineForClassFields": true,
+    "rewriteRelativeImportExtensions": true
+  }
+}

fixtures/tsconfig/cases/extends-compiler-options/base-tsconfig.json

@@ -8,8 +8,8 @@ use std::path::Path;
 use crate::{ResolveOptions, Resolver, TsConfig, TsconfigOptions, TsconfigReferences};
 
 #[test]
-fn test_extend_tsconfig_base_url() {
-    let f = super::fixture_root().join("tsconfig/cases/extends-base-url");
+fn test_extend_tsconfig_compiler_options() {
+    let f = super::fixture_root().join("tsconfig/cases/extends-compiler-options");
 
     let resolver = Resolver::new(ResolveOptions {
         tsconfig: Some(TsconfigOptions {
@@ -22,8 +22,11 @@ fn test_extend_tsconfig_base_url() {
     let resolution = resolver.resolve_tsconfig(&f).expect("resolved");
     let compiler_options = resolution.compiler_options();
 
-    // Should inherit baseUrl from parent
+    // Should inherit compilerOptions from parent
     assert_eq!(compiler_options.base_url, Some(f.join("src")));
+    assert_eq!(compiler_options.emit_decorator_metadata, Some(true));
+    assert_eq!(compiler_options.use_define_for_class_fields, Some(true));
+    assert_eq!(compiler_options.rewrite_relative_import_extensions, Some(true));
 }
 
 #[test]

fixtures/tsconfig/cases/extends-base-url/tsconfig.json renamed to fixtures/tsconfig/cases/extends-compiler-options/tsconfig.json

@@ -133,6 +133,7 @@ impl TsConfig {
     }
 
     /// Inherits settings from the given tsconfig into `self`.
+    #[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
     pub(crate) fn extend_tsconfig(&mut self, tsconfig: &Self) {
         let compiler_options = self.compiler_options_mut();
 
@@ -171,6 +172,31 @@ impl TsConfig {
             }
         }
 
+        if compiler_options.emit_decorator_metadata.is_none() {
+            if let Some(emit_decorator_metadata) =
+                tsconfig.compiler_options().emit_decorator_metadata()
+            {
+                compiler_options.set_emit_decorator_metadata(*emit_decorator_metadata);
+            }
+        }
+
+        if compiler_options.use_define_for_class_fields.is_none() {
+            if let Some(use_define_for_class_fields) =
+                tsconfig.compiler_options().use_define_for_class_fields()
+            {
+                compiler_options.set_use_define_for_class_fields(*use_define_for_class_fields);
+            }
+        }
+
+        if compiler_options.rewrite_relative_import_extensions.is_none() {
+            if let Some(rewrite_relative_import_extensions) =
+                tsconfig.compiler_options().rewrite_relative_import_extensions()
+            {
+                compiler_options
+                    .set_rewrite_relative_import_extensions(*rewrite_relative_import_extensions);
+            }
+        }
+
         if compiler_options.jsx().is_none() {
             if let Some(jsx) = tsconfig.compiler_options().jsx() {
                 compiler_options.set_jsx(jsx.to_string());
@@ -475,15 +501,35 @@ impl CompilerOptions {
         self.experimental_decorators = Some(experimental_decorators);
     }
 
-    // /// Whether to emit decorator metadata.
-    // fn emit_decorator_metadata(&self) -> Option<&bool> {
-    //     self.emit_decorator_metadata.as_ref()
-    // }
+    /// Whether to emit decorator metadata.
+    fn emit_decorator_metadata(&self) -> Option<&bool> {
+        self.emit_decorator_metadata.as_ref()
+    }
+
+    /// Sets whether to emit decorator metadata.
+    fn set_emit_decorator_metadata(&mut self, emit_decorator_metadata: bool) {
+        self.emit_decorator_metadata = Some(emit_decorator_metadata);
+    }
+
+    /// Whether to use define for class fields.
+    fn use_define_for_class_fields(&self) -> Option<&bool> {
+        self.use_define_for_class_fields.as_ref()
+    }
 
-    // /// Sets whether to emit decorator metadata.
-    // fn set_emit_decorator_metadata(&mut self, emit_decorator_metadata: bool) {
-    //     self.emit_decorator_metadata = Some(emit_decorator_metadata);
-    // }
+    /// Sets whether to use define for class fields.
+    fn set_use_define_for_class_fields(&mut self, use_define_for_class_fields: bool) {
+        self.use_define_for_class_fields = Some(use_define_for_class_fields);
+    }
+
+    /// Whether to rewrite relative import extensions.
+    fn rewrite_relative_import_extensions(&self) -> Option<&bool> {
+        self.rewrite_relative_import_extensions.as_ref()
+    }
+
+    /// Sets whether to rewrite relative import extensions.
+    fn set_rewrite_relative_import_extensions(&mut self, rewrite_relative_import_extensions: bool) {
+        self.rewrite_relative_import_extensions = Some(rewrite_relative_import_extensions);
+    }
 
     /// JSX.
     fn jsx(&self) -> Option<&str> {