@effect/language-service 0.21.8 → 0.22.1

package/transform.js

@@ -754,8 +754,6 @@ var fromIterable = (collection) => Array.isArray(collection) ? collection : Arra
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
 var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
 var isArray = Array.isArray;
-var isEmptyArray = (self) => self.length === 0;
-var isEmptyReadonlyArray = isEmptyArray;
 var sort = /* @__PURE__ */ dual(2, (self, O) => {
   const out = Array.from(self);
   out.sort(O);
@@ -777,20 +775,6 @@ var intersectionWith = (isEquivalent) => {
 var intersection = /* @__PURE__ */ intersectionWith(_equivalence);
 var empty = () => [];
 var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
-var flatMap = /* @__PURE__ */ dual(2, (self, f) => {
-  if (isEmptyReadonlyArray(self)) {
-    return [];
-  }
-  const out = [];
-  for (let i = 0; i < self.length; i++) {
-    const inner = f(self[i], i);
-    for (let j = 0; j < inner.length; j++) {
-      out.push(inner[j]);
-    }
-  }
-  return out;
-});
-var flatten = /* @__PURE__ */ flatMap(identity);
 var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
   const as = fromIterable(self);
   const out = [];
@@ -803,29 +787,11 @@ var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
 });
 
 // src/core/Nano.ts
-var NanoInternalSuccessProto = {
-  _tag: "Right"
-};
 function makeInternalSuccess(value) {
-  const result = Object.create(NanoInternalSuccessProto);
-  result.value = value;
-  return result;
+  return { _tag: "Right", value };
 }
-var NanoInternalFailureProto = {
-  _tag: "Left"
-};
-function makeInternalFailure(value) {
-  const result = Object.create(NanoInternalFailureProto);
-  result.value = value;
-  return result;
-}
-var NanoInternalDefectProto = {
-  _tag: "Defect"
-};
 function makeInternalDefect(value) {
-  const result = Object.create(NanoInternalDefectProto);
-  result.value = value;
-  return result;
+  return { _tag: "Defect", value };
 }
 var NanoDefectException = class {
   constructor(message) {
@@ -840,17 +806,14 @@ var NanoTag = class {
 };
 var Tag = (identifier) => new NanoTag(identifier);
 var contextEmpty = { value: {} };
-var Proto = {
-  run: () => {
-  },
-  [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this));
-  }
-};
 function make2(run2) {
-  const result = Object.create(Proto);
-  result.run = run2;
-  return result;
+  const nano = {
+    run: run2,
+    [Symbol.iterator]() {
+      return new SingleShotGen(new YieldWrap(this));
+    }
+  };
+  return nano;
 }
 var unsafeRun = (fa) => {
   const program = provideService(internalNanoCache, {})(fa);
@@ -871,10 +834,34 @@ var run = (fa) => {
     return left2(new NanoDefectException(e));
   }
 };
-var succeed = (value) => make2(() => makeInternalSuccess(value));
-var fail = (value) => make2(() => makeInternalFailure(value));
-var sync = (value) => make2(() => makeInternalSuccess(value()));
-var flatMap2 = dual(2, (fa, f) => make2((ctx) => {
+var succeed = (value) => {
+  const nano = {
+    run: () => ({ _tag: "Right", value }),
+    [Symbol.iterator]() {
+      return new SingleShotGen(new YieldWrap(this));
+    }
+  };
+  return nano;
+};
+var fail = (value) => {
+  const nano = {
+    run: () => ({ _tag: "Left", value }),
+    [Symbol.iterator]() {
+      return new SingleShotGen(new YieldWrap(this));
+    }
+  };
+  return nano;
+};
+var sync = (value) => {
+  const nano = {
+    run: () => ({ _tag: "Right", value: value() }),
+    [Symbol.iterator]() {
+      return new SingleShotGen(new YieldWrap(this));
+    }
+  };
+  return nano;
+};
+var flatMap = dual(2, (fa, f) => make2((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
   return f(result.value).run(ctx);
@@ -965,8 +952,9 @@ function cachedBy(fa, key, lookupKey) {
       cacheObj[key] = cache;
     }
     const lookup = lookupKey(...args);
-    if (cache.has(lookup)) {
-      return cache.get(lookup);
+    const cached2 = cache.get(lookup);
+    if (cached2 !== void 0) {
+      return cached2;
     }
     const result = fa(...args).run(ctx);
     cache.set(lookup, result);
@@ -996,7 +984,8 @@ function parse(config) {
     quickinfo: isObject(config) && hasProperty(config, "quickinfo") && isBoolean(config.quickinfo) ? config.quickinfo : true,
     completions: isObject(config) && hasProperty(config, "completions") && isBoolean(config.completions) ? config.completions : true,
     goto: isObject(config) && hasProperty(config, "goto") && isBoolean(config.goto) ? config.goto : true,
-    allowedDuplicatedPackages: isObject(config) && hasProperty(config, "allowedDuplicatedPackages") && isArray(config.allowedDuplicatedPackages) && config.allowedDuplicatedPackages.every(isString) ? config.allowedDuplicatedPackages.map((_) => _.toLowerCase()) : []
+    allowedDuplicatedPackages: isObject(config) && hasProperty(config, "allowedDuplicatedPackages") && isArray(config.allowedDuplicatedPackages) && config.allowedDuplicatedPackages.every(isString) ? config.allowedDuplicatedPackages.map((_) => _.toLowerCase()) : [],
+    namespaceImportPackages: isObject(config) && hasProperty(config, "namespaceImportPackages") && isArray(config.namespaceImportPackages) && config.namespaceImportPackages.every(isString) ? config.namespaceImportPackages.map((_) => _.toLowerCase()) : []
   };
 }
 
@@ -1028,6 +1017,20 @@ function parsePackageContentNameAndVersionFromScope(v) {
     packageDirectory: packageJsonScope.packageDirectory
   };
 }
+function makeGetModuleSpecifier(ts) {
+  if (!(hasProperty(ts, "moduleSpecifiers") && hasProperty(ts.moduleSpecifiers, "getModuleSpecifier") && isFunction2(ts.moduleSpecifiers.getModuleSpecifier))) return;
+  const _internal = ts.moduleSpecifiers.getModuleSpecifier;
+  return (compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, options) => {
+    return _internal(
+      compilerOptions,
+      importingSourceFile,
+      importingSourceFileName,
+      toFileName,
+      host,
+      options
+    );
+  };
+}
 
 // src/core/LSP.ts
 var RefactorNotApplicableError = class {
@@ -1043,40 +1046,9 @@ var getSemanticDiagnosticsWithCodeFixes = fn(
   let effectCodeFixes = [];
   const executor = yield* createDiagnosticExecutor(sourceFile);
   for (const rule of rules) {
-    const result = yield* option(executor.execute(rule));
-    if (isSome2(result)) {
-      effectDiagnostics = effectDiagnostics.concat(
-        pipe(
-          result.value,
-          map2((_) => ({
-            file: sourceFile,
-            start: _.node.getStart(sourceFile),
-            length: _.node.getEnd() - _.node.getStart(sourceFile),
-            messageText: _.messageText,
-            category: _.category,
-            code: rule.code,
-            source: "effect"
-          }))
-        )
-      );
-      effectCodeFixes = effectCodeFixes.concat(
-        pipe(
-          result.value,
-          map2(
-            (_) => map2(
-              _.fixes,
-              (fix) => ({
-                ...fix,
-                code: rule.code,
-                start: _.node.getStart(sourceFile),
-                end: _.node.getEnd()
-              })
-            )
-          ),
-          flatten
-        )
-      );
-    }
+    const { codeFixes, diagnostics: diagnostics2 } = yield* executor.execute(rule);
+    effectDiagnostics = effectDiagnostics.concat(diagnostics2);
+    effectCodeFixes = effectCodeFixes.concat(codeFixes);
   }
   return {
     diagnostics: effectDiagnostics,
@@ -1207,12 +1179,14 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       suggestion: ts.DiagnosticCategory.Suggestion
     };
     const execute = fn("LSP.ruleExecutor")(function* (rule) {
+      const diagnostics2 = [];
+      const codeFixes = [];
       const ruleNameLowered = rule.name.toLowerCase();
-      if (skippedRules.indexOf(ruleNameLowered) > -1) return [];
+      if (skippedRules.indexOf(ruleNameLowered) > -1) return { diagnostics: diagnostics2, codeFixes };
       const fixByDisableNextLine = (_) => ({
         fixName: rule.name + "_skipNextLine",
         description: "Disable " + rule.name + " for this line",
-        apply: flatMap2(
+        apply: flatMap(
           service(ChangeTracker),
           (changeTracker) => sync(() => {
             const disableAtNode = findParentStatementForDisableNextLine(_.node);
@@ -1229,7 +1203,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       const fixByDisableEntireFile = {
         fixName: rule.name + "_skipFile",
         description: "Disable " + rule.name + " for this entire file",
-        apply: flatMap2(
+        apply: flatMap(
           service(ChangeTracker),
           (changeTracker) => sync(
             () => changeTracker.insertText(
@@ -1241,16 +1215,15 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
           )
         )
       };
-      let modifiedDiagnostics = [];
+      const applicableDiagnostics = [];
       yield* rule.apply(sourceFile, (entry) => {
-        modifiedDiagnostics.push({
+        applicableDiagnostics.push({
           ...entry,
           fixes: entry.fixes.concat([fixByDisableNextLine(entry), fixByDisableEntireFile])
         });
       });
-      if (!(ruleNameLowered in pluginOptions.diagnosticSeverity || ruleNameLowered in sectionOverrides || ruleNameLowered in lineOverrides)) return modifiedDiagnostics;
-      for (const emitted of modifiedDiagnostics.slice(0)) {
-        let newLevel = pluginOptions.diagnosticSeverity[ruleNameLowered];
+      for (const emitted of applicableDiagnostics.slice(0)) {
+        let newLevel = pluginOptions.diagnosticSeverity[ruleNameLowered] || rule.severity;
         const lineOverride = (lineOverrides[ruleNameLowered] || []).find(
           (_) => _.pos < emitted.node.getStart(sourceFile) && _.end >= emitted.node.getEnd()
         );
@@ -1262,13 +1235,26 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
           );
           if (sectionOverride) newLevel = sectionOverride.level;
         }
-        if (newLevel === "off") {
-          modifiedDiagnostics = modifiedDiagnostics.filter((_) => _ !== emitted);
-        } else {
-          emitted.category = newLevel && newLevel in levelToDiagnosticCategory ? levelToDiagnosticCategory[newLevel] : emitted.category;
+        if (!(newLevel in levelToDiagnosticCategory)) continue;
+        diagnostics2.push({
+          file: sourceFile,
+          start: emitted.node.getStart(sourceFile),
+          length: emitted.node.getEnd() - emitted.node.getStart(sourceFile),
+          messageText: emitted.messageText,
+          category: levelToDiagnosticCategory[newLevel],
+          code: rule.code,
+          source: "effect"
+        });
+        for (const fix of emitted.fixes) {
+          codeFixes.push({
+            ...fix,
+            code: rule.code,
+            start: emitted.node.getStart(sourceFile),
+            end: emitted.node.getEnd()
+          });
         }
       }
-      return modifiedDiagnostics;
+      return { diagnostics: diagnostics2, codeFixes };
     });
     return { execute };
   }
@@ -1525,6 +1511,15 @@ var appendToUniqueTypesMap = fn(
     };
   }
 );
+function makeResolveExternalModuleName(typeChecker) {
+  if (!(hasProperty(typeChecker, "resolveExternalModuleName") && isFunction(typeChecker.resolveExternalModuleName))) {
+    return;
+  }
+  const _internal = typeChecker.resolveExternalModuleName;
+  return (moduleSpecifier) => {
+    return _internal(moduleSpecifier);
+  };
+}
 
 // src/core/AST.ts
 function collectSelfAndAncestorNodesInRange(node, textRange) {
@@ -2359,8 +2354,8 @@ var programResolvedCacheSize = /* @__PURE__ */ new Map();
 var duplicatePackage = createDiagnostic({
   name: "duplicatePackage",
   code: 6,
+  severity: "warning",
   apply: fn("duplicatePackage.apply")(function* (sourceFile, report) {
-    const ts = yield* service(TypeScriptApi);
     const program = yield* service(TypeScriptProgram);
     const options = yield* service(LanguageServicePluginOptions);
     if (sourceFile.statements.length < 1) return;
@@ -2389,7 +2384,6 @@ var duplicatePackage = createDiagnostic({
         const versions = Object.keys(resolvedPackages[packageName]);
         report({
           node: sourceFile.statements[0],
-          category: ts.DiagnosticCategory.Warning,
           messageText: `Package ${packageName} is referenced multiple times with different versions (${versions.join(", ")}) and may cause unexpected type errors.
 Cleanup your dependencies and your package lockfile to avoid multiple instances of this package and reload the project.
 If this is intended set the LSP config "allowedDuplicatedPackages" to ${JSON.stringify(options.allowedDuplicatedPackages.concat([packageName]))}.
@@ -2406,6 +2400,7 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
 var floatingEffect = createDiagnostic({
   name: "floatingEffect",
   code: 3,
+  severity: "error",
   apply: fn("floatingEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -2438,7 +2433,6 @@ var floatingEffect = createDiagnostic({
         if (isNone2(allowedFloatingEffects)) {
           report({
             node,
-            category: ts.DiagnosticCategory.Error,
             messageText: `Effect must be yielded or assigned to a variable.`,
             fixes: []
           });
@@ -2452,6 +2446,7 @@ var floatingEffect = createDiagnostic({
 var genericEffectServices = createDiagnostic({
   name: "genericEffectServices",
   code: 10,
+  severity: "warning",
   apply: fn("genericEffectServices.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -2481,7 +2476,6 @@ var genericEffectServices = createDiagnostic({
           map3(() => {
             report({
               node: reportAt,
-              category: ts.DiagnosticCategory.Warning,
               messageText: `Effect Services with type parameters are not supported because they cannot be properly discriminated at runtime, which may cause unexpected behavior.`,
               fixes: []
             });
@@ -2494,10 +2488,124 @@ var genericEffectServices = createDiagnostic({
   })
 });
 
+// src/diagnostics/importFromBarrel.ts
+var importFromBarrel = createDiagnostic({
+  name: "importFromBarrel",
+  code: 12,
+  severity: "off",
+  apply: fn("importFromBarrel.apply")(function* (sourceFile, report) {
+    const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
+    if (languageServicePluginOptions.namespaceImportPackages.length === 0) return;
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const program = yield* service(TypeScriptProgram);
+    const isImportedFromBarrelExport = (element, languageServicePluginOptions2) => {
+      const getModuleSpecifier = makeGetModuleSpecifier(ts);
+      const resolveExternalModuleName = makeResolveExternalModuleName(typeChecker);
+      if (!(getModuleSpecifier && resolveExternalModuleName)) return;
+      const importDeclaration = ts.findAncestor(element, (node) => ts.isImportDeclaration(node));
+      if (!importDeclaration) return;
+      if (!ts.isStringLiteral(importDeclaration.moduleSpecifier)) return;
+      const importClause = importDeclaration.importClause;
+      if (!importClause) return;
+      const namedBindings = importClause.namedBindings;
+      if (!namedBindings) return;
+      if (!ts.isNamedImports(namedBindings)) return;
+      const barrelModuleName = importDeclaration.moduleSpecifier.text;
+      if (languageServicePluginOptions2.namespaceImportPackages.indexOf(barrelModuleName.toLowerCase()) === -1) return;
+      const moduleSymbol = resolveExternalModuleName(importDeclaration.moduleSpecifier);
+      if (!moduleSymbol) return;
+      if (!moduleSymbol.exports) return;
+      const sourceFile2 = importDeclaration.getSourceFile();
+      const nodeForSymbol = element.propertyName || element.name;
+      if (!ts.isIdentifier(nodeForSymbol)) return;
+      const importedName = nodeForSymbol.text;
+      const reexportedSymbol = moduleSymbol.exports.get(ts.escapeLeadingUnderscores(importedName));
+      if (!reexportedSymbol) return;
+      if (!(reexportedSymbol.declarations && reexportedSymbol.declarations.length === 1)) return;
+      const namespaceExport = reexportedSymbol.declarations[0];
+      if (!ts.isNamespaceExport(namespaceExport)) return;
+      const exportDeclaration = namespaceExport.parent;
+      if (!ts.isExportDeclaration(exportDeclaration)) return;
+      if (!exportDeclaration.moduleSpecifier) return;
+      const originalModuleSymbol = resolveExternalModuleName(exportDeclaration.moduleSpecifier);
+      if (!originalModuleSymbol) return;
+      if (!originalModuleSymbol.valueDeclaration) return;
+      const originalSourceFile = originalModuleSymbol.valueDeclaration.getSourceFile();
+      const unbarrelledFileName = getModuleSpecifier(
+        program.getCompilerOptions(),
+        sourceFile2,
+        sourceFile2.fileName,
+        originalSourceFile.fileName,
+        program
+      );
+      if (unbarrelledFileName.toLowerCase().indexOf(barrelModuleName.toLowerCase() + "/") === -1) return;
+      return { unbarrelledFileName, importedName, barrelModuleName, importClause, namedBindings, importDeclaration };
+    };
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      const parent = node.parent;
+      if (!(ts.isImportSpecifier(node) && ts.isNamedImports(parent))) {
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      }
+      const result = isImportedFromBarrelExport(node, languageServicePluginOptions);
+      if (!result) continue;
+      const { barrelModuleName, importClause, importDeclaration, importedName, namedBindings, unbarrelledFileName } = result;
+      report({
+        node,
+        messageText: `Importing from barrel module ${barrelModuleName} is not allowed.`,
+        fixes: [
+          {
+            fixName: "replaceWithUnbarrelledImport",
+            description: `Import * as ${importedName} from ${unbarrelledFileName}`,
+            apply: gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              const newImport = ts.factory.createImportDeclaration(
+                void 0,
+                ts.factory.createImportClause(
+                  importClause.isTypeOnly || node.isTypeOnly,
+                  void 0,
+                  ts.factory.createNamespaceImport(ts.factory.createIdentifier(importedName))
+                ),
+                ts.factory.createStringLiteral(unbarrelledFileName)
+              );
+              if (namedBindings.elements.length === 1) {
+                changeTracker.replaceNode(
+                  sourceFile,
+                  importDeclaration,
+                  newImport
+                );
+              } else {
+                changeTracker.insertNodeAfter(sourceFile, importDeclaration, newImport);
+                changeTracker.replaceNode(
+                  sourceFile,
+                  namedBindings,
+                  ts.factory.updateNamedImports(
+                    namedBindings,
+                    namedBindings.elements.filter((e) => e !== node)
+                  )
+                );
+              }
+            })
+          }
+        ]
+      });
+    }
+  })
+});
+
 // src/diagnostics/leakingRequirements.ts
 var leakingRequirements = createDiagnostic({
   name: "leakingRequirements",
   code: 8,
+  severity: "suggestion",
   apply: fn("leakingRequirements.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -2555,7 +2663,6 @@ var leakingRequirements = createDiagnostic({
       if (requirements.length === 0) return;
       report({
         node,
-        category: ts.DiagnosticCategory.Warning,
         messageText: `This Service is leaking the ${requirements.map((_) => typeChecker.typeToString(_)).join(" | ")} requirement.
 If these requirements cannot be cached and are expected to be provided per method invocation (e.g. HttpServerRequest), you can safely disable this diagnostic for this line through quickfixes.
 More info at https://effect.website/docs/requirements-management/layers/#avoiding-requirement-leakage`,
@@ -2586,7 +2693,7 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
       for (const [type, reportAt] of typesToCheck) {
         yield* pipe(
           typeParser.contextTag(type, node),
-          flatMap2(
+          flatMap(
             ({ Service }) => pipe(
               parseLeakedRequirements(Service, node),
               map3((requirements) => reportLeakingRequirements(reportAt, sort(requirements, typeOrder)))
@@ -2604,8 +2711,8 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
 var missingEffectContext = createDiagnostic({
   name: "missingEffectContext",
   code: 1,
+  severity: "error",
   apply: fn("missingEffectContext.apply")(function* (sourceFile, report) {
-    const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
@@ -2614,7 +2721,7 @@ var missingEffectContext = createDiagnostic({
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
-      flatMap2(
+      flatMap(
         ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
           realEffect.R,
           expectedEffect.R
@@ -2624,23 +2731,24 @@ var missingEffectContext = createDiagnostic({
     const sortTypes = sort(typeOrder);
     const entries = yield* expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries) {
-      const missingContext = yield* pipe(
-        checkForMissingContextTypes(
-          node,
-          expectedType,
-          valueNode,
-          realType
-        ),
-        orElse2(() => succeed([]))
-      );
-      if (missingContext.length > 0) {
-        report(
-          {
+      if (expectedType !== realType) {
+        yield* pipe(
+          checkForMissingContextTypes(
             node,
-            category: ts.DiagnosticCategory.Error,
-            messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`,
-            fixes: []
-          }
+            expectedType,
+            valueNode,
+            realType
+          ),
+          map3(
+            (missingTypes) => missingTypes.length > 0 ? report(
+              {
+                node,
+                messageText: `Missing '${sortTypes(missingTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`,
+                fixes: []
+              }
+            ) : void 0
+          ),
+          ignore
         );
       }
     }
@@ -2651,8 +2759,8 @@ var missingEffectContext = createDiagnostic({
 var missingEffectError = createDiagnostic({
   name: "missingEffectError",
   code: 1,
+  severity: "error",
   apply: fn("missingEffectError.apply")(function* (sourceFile, report) {
-    const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
@@ -2661,7 +2769,7 @@ var missingEffectError = createDiagnostic({
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
-      flatMap2(
+      flatMap(
         ([expectedEffect, realEffect]) => getMissingTypeEntriesInTargetType(
           realEffect.E,
           expectedEffect.E
@@ -2671,23 +2779,24 @@ var missingEffectError = createDiagnostic({
     const sortTypes = sort(typeOrder);
     const entries = yield* expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries) {
-      const missingContext = yield* pipe(
-        checkForMissingErrorTypes(
-          node,
-          expectedType,
-          valueNode,
-          realType
-        ),
-        orElse2(() => succeed([]))
-      );
-      if (missingContext.length > 0) {
-        report(
-          {
+      if (expectedType !== realType) {
+        yield* pipe(
+          checkForMissingErrorTypes(
             node,
-            category: ts.DiagnosticCategory.Error,
-            messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
-            fixes: []
-          }
+            expectedType,
+            valueNode,
+            realType
+          ),
+          map3(
+            (missingTypes) => missingTypes.length > 0 ? report(
+              {
+                node,
+                messageText: `Missing '${sortTypes(missingTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
+                fixes: []
+              }
+            ) : void 0
+          ),
+          ignore
         );
       }
     }
@@ -2698,6 +2807,7 @@ var missingEffectError = createDiagnostic({
 var missingReturnYieldStar = createDiagnostic({
   name: "missingReturnYieldStar",
   code: 7,
+  severity: "error",
   apply: fn("missingReturnYieldStar.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -2745,7 +2855,6 @@ var missingReturnYieldStar = createDiagnostic({
                 }] : [];
                 report({
                   node,
-                  category: ts.DiagnosticCategory.Error,
                   messageText: `Yielded Effect never succeeds, so it is best to use a 'return yield*' instead.`,
                   fixes: fix
                 });
@@ -2762,6 +2871,7 @@ var missingReturnYieldStar = createDiagnostic({
 var missingStarInYieldEffectGen = createDiagnostic({
   name: "missingStarInYieldEffectGen",
   code: 4,
+  severity: "error",
   apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -2801,7 +2911,6 @@ var missingStarInYieldEffectGen = createDiagnostic({
     brokenGenerators.forEach(
       (node) => report({
         node,
-        category: ts.DiagnosticCategory.Error,
         messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`,
         fixes: []
       })
@@ -2824,7 +2933,6 @@ var missingStarInYieldEffectGen = createDiagnostic({
       }] : [];
       report({
         node,
-        category: ts.DiagnosticCategory.Error,
         messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`,
         fixes: fix
       });
@@ -2836,6 +2944,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
 var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
   code: 11,
+  severity: "suggestion",
   apply: fn("returnEffectInGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -2883,7 +2992,6 @@ var returnEffectInGen = createDiagnostic({
                 }] : [];
                 report({
                   node,
-                  category: ts.DiagnosticCategory.Suggestion,
                   messageText: `You are returning an Effect-able type inside a generator function, and will result in nested Effect<Effect<...>>.
 Maybe you wanted to return yield* instead?
 Nested Effect-able types may be intended if you plan to later manually flatten or unwrap this Effect, if so you can safely disable this diagnostic for this line through quickfixes.`,
@@ -2903,6 +3011,7 @@ Nested Effect-able types may be intended if you plan to later manually flatten o
 var unnecessaryEffectGen = createDiagnostic({
   name: "unnecessaryEffectGen",
   code: 5,
+  severity: "suggestion",
   apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -2921,7 +3030,6 @@ var unnecessaryEffectGen = createDiagnostic({
           map3(
             ({ replacementNode }) => report({
               node,
-              category: ts.DiagnosticCategory.Suggestion,
               messageText: `This Effect.gen contains a single return statement.`,
               fixes: [{
                 fixName: "unnecessaryEffectGen_fix",
@@ -2946,6 +3054,7 @@ var unnecessaryEffectGen = createDiagnostic({
 var unnecessaryPipe = createDiagnostic({
   name: "unnecessaryPipe",
   code: 9,
+  severity: "suggestion",
   apply: fn("unnecessaryPipe.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -2965,7 +3074,6 @@ var unnecessaryPipe = createDiagnostic({
             if (args.length === 0) {
               report({
                 node,
-                category: ts.DiagnosticCategory.Suggestion,
                 messageText: `This pipe call contains no arguments.`,
                 fixes: [{
                   fixName: "unnecessaryPipe_fix",
@@ -2999,7 +3107,8 @@ var diagnostics = [
   leakingRequirements,
   unnecessaryPipe,
   genericEffectServices,
-  returnEffectInGen
+  returnEffectInGen,
+  importFromBarrel
 ];
 
 // src/transform.ts