fix: wrong error & warn code definition (#1500)

kazupon · web-flow · commit fa87f7dac8fe · 2023-08-22T17:17:56.000+09:00
diff --git a/packages/core-base/src/context.ts b/packages/core-base/src/context.ts
@@ -9,11 +9,12 @@ import {
   isFunction,
   isPlainObject,
   assign,
-  isObject
+  isObject,
+  warnOnce
 } from '@intlify/shared'
 import { VueDevToolsTimelineEvents } from '@intlify/vue-devtools'
 import { initI18nDevTools } from './devtools'
-import { CoreWarnCodes, getWarnMessage, warnOnce } from './warnings'
+import { CoreWarnCodes, getWarnMessage } from './warnings'
 import { resolveWithKeyValue } from './resolver'
 import { fallbackWithSimple } from './fallbacker'
 
diff --git a/packages/core-base/src/errors.ts b/packages/core-base/src/errors.ts
@@ -1,22 +1,22 @@
+import { incrementer } from '@intlify/shared'
 import {
   CompileErrorCodes,
   createCompileError
 } from '@intlify/message-compiler'
-import type { CompileError } from '@intlify/message-compiler'
 
-export interface CoreError extends CompileError {
-  code: CoreErrorCodes
-}
+import type { BaseError } from '@intlify/shared'
+
+export interface CoreError extends BaseError {}
 
-let code = CompileErrorCodes.__EXTEND_POINT__
-const inc = () => ++code
+const code = CompileErrorCodes.__EXTEND_POINT__
+const inc = incrementer(code)
 
 export const CoreErrorCodes = {
-  INVALID_ARGUMENT: code, // 15
-  INVALID_DATE_ARGUMENT: inc(), // 16
-  INVALID_ISO_DATE_ARGUMENT: inc(), // 17
-  NOT_SUPPORT_NON_STRING_MESSAGE: inc(), // 18
-  __EXTEND_POINT__: inc() // 19
+  INVALID_ARGUMENT: code, // 18
+  INVALID_DATE_ARGUMENT: inc(), // 19
+  INVALID_ISO_DATE_ARGUMENT: inc(), // 20
+  NOT_SUPPORT_NON_STRING_MESSAGE: inc(), // 21
+  __EXTEND_POINT__: inc() // 22
 } as const
 
 export type CoreErrorCodes =
diff --git a/packages/core-base/src/warnings.ts b/packages/core-base/src/warnings.ts
@@ -1,4 +1,4 @@
-import { format, warn } from '@intlify/shared'
+import { format } from '@intlify/shared'
 
 export const CoreWarnCodes = {
   NOT_FOUND_KEY: 1,
@@ -24,15 +24,6 @@ export const warnMessages: { [code: number]: string } = {
   [CoreWarnCodes.EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER]: `This project is using Custom Message Compiler, which is an experimental feature. It may receive breaking changes or be removed in the future.`
 }
 
-const hasWarned: Record<string, boolean> = {}
-
-export function warnOnce(msg: string) {
-  if (!hasWarned[msg]) {
-    hasWarned[msg] = true
-    warn(msg)
-  }
-}
-
 export function getWarnMessage(
   code: CoreWarnCodes,
   ...args: unknown[]
diff --git a/packages/message-compiler/src/errors.ts b/packages/message-compiler/src/errors.ts
@@ -1,21 +1,22 @@
 import { format } from '@intlify/shared'
 
+import type { BaseError } from '@intlify/shared'
 import type { SourceLocation } from './location'
 
 export type CompileDomain =
   | 'tokenizer'
   | 'parser'
   | 'generator'
   | 'transformer'
-  | 'compiler'
+  | 'optimizer'
+  | 'minifier'
 
-export interface CompileError extends SyntaxError {
-  code: number
+export interface CompileError extends BaseError, SyntaxError {
   domain?: CompileDomain
   location?: SourceLocation
 }
 
-export interface CreateCompileErrorOptions {
+export interface CompileErrorOptions {
   domain?: CompileDomain
   messages?: { [code: number]: string }
   args?: unknown[]
@@ -40,10 +41,16 @@ export const CompileErrorCodes = {
   UNEXPECTED_EMPTY_LINKED_KEY: 13,
   UNEXPECTED_LEXICAL_ANALYSIS: 14,
 
+  // generator error codes
+  UNHANDLED_CODEGEN_NODE_TYPE: 15,
+
+  // minifier error codes
+  UNHANDLED_MINIFIER_NODE_TYPE: 16,
+
   // Special value for higher-order compilers to pick up the last code
   // to avoid collision of error codes. This should always be kept as the last
   // item.
-  __EXTEND_POINT__: 15
+  __EXTEND_POINT__: 17
 } as const
 
 export type CompileErrorCodes =
@@ -66,13 +73,17 @@ export const errorMessages: { [code: number]: string } = {
   [CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL]: `Plural must have messages`,
   [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER]: `Unexpected empty linked modifier`,
   [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY]: `Unexpected empty linked key`,
-  [CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`
+  [CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`,
+  // generator error messages
+  [CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE]: `unhandled codegen node type: '{0}'`,
+  // minimizer error messages
+  [CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE]: `unhandled mimifier node type: '{0}'`
 }
 
 export function createCompileError<T extends number>(
   code: T,
   loc: SourceLocation | null,
-  options: CreateCompileErrorOptions = {}
+  options: CompileErrorOptions = {}
 ): CompileError {
   const { domain, messages, args } = options
   const msg = __DEV__
diff --git a/packages/message-compiler/src/generator.ts b/packages/message-compiler/src/generator.ts
@@ -3,6 +3,7 @@ import { SourceMapGenerator } from 'source-map-js'
 import { NodeTypes } from './nodes'
 import { LOCATION_STUB } from './location'
 import { HelperNameMap } from './helpers'
+import { createCompileError, CompileErrorCodes } from './errors'
 
 import type { RawSourceMap } from 'source-map-js'
 import type {
@@ -58,6 +59,8 @@ type CodeGenerator = {
   needIndent(): boolean
 }
 
+export const ERROR_DOMAIN = 'parser'
+
 function createCodeGenerator(
   ast: ResourceNode,
   options: CodeGenOptions
@@ -264,7 +267,14 @@ function generateNode(generator: CodeGenerator, node: Node): void {
       break
     default:
       if (__DEV__) {
-        throw new Error(`unhandled codegen node type: ${node.type}`)
+        throw createCompileError(
+          CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE,
+          null,
+          {
+            domain: ERROR_DOMAIN,
+            args: [node.type]
+          }
+        )
       }
   }
 }
diff --git a/packages/message-compiler/src/minifier.ts b/packages/message-compiler/src/minifier.ts
@@ -1,4 +1,5 @@
 import { NodeTypes } from './nodes'
+import { createCompileError, CompileErrorCodes } from './errors'
 
 import type {
   MessageNode,
@@ -14,6 +15,8 @@ import type {
   NamedNode
 } from './nodes'
 
+export const ERROR_DOMAIN = 'minifier'
+
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 export function minify(node: Node) {
@@ -85,7 +88,14 @@ export function minify(node: Node) {
       break
     default:
       if (__DEV__) {
-        throw new Error(`unhandled minify node type: ${node.type}`)
+        throw createCompileError(
+          CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE,
+          null,
+          {
+            domain: ERROR_DOMAIN,
+            args: [node.type]
+          }
+        )
       }
   }
 
diff --git a/packages/message-compiler/test/generator.test.ts b/packages/message-compiler/test/generator.test.ts
@@ -1,12 +1,15 @@
 /* eslint-disable no-irregular-whitespace */
 
+import { format } from '@intlify/shared'
 import { createParser } from '../src/parser'
 import { transform } from '../src/transformer'
 import { generate } from '../src/generator'
-import { SourceMapConsumer } from 'source-map-js'
 import { CHAR_CR, CHAR_LF, CHAR_LS, CHAR_PS } from '../src/scanner'
+import { CompileErrorCodes, errorMessages } from '../src/errors'
+import { SourceMapConsumer } from 'source-map-js'
 
 import type { RawSourceMap } from 'source-map-js'
+import type { ResourceNode } from '../src/nodes'
 
 interface Pos {
   line: number
@@ -511,4 +514,17 @@ test('disable source map with location: false', async () => {
   })
 })
 
+test('unhandle error', () => {
+  // wrong node type
+  const type = 1024
+  const ast = {
+    type
+  } as unknown as ResourceNode
+  expect(() =>
+    generate(ast, { sourceMap: true, location: false })
+  ).toThrowError(
+    format(errorMessages[CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE], type)
+  )
+})
+
 /* eslint-enable no-irregular-whitespace */
diff --git a/packages/message-compiler/test/minifier.test.ts b/packages/message-compiler/test/minifier.test.ts
@@ -1,8 +1,10 @@
+import { format } from '@intlify/shared'
 import { createParser } from '../src/parser'
 import { optimize } from '../src/optimizer'
 import { minify } from '../src/minifier'
+import { CompileErrorCodes, errorMessages } from '../src/errors'
 
-import type { MessageNode, PluralNode } from '../src/nodes'
+import type { MessageNode, PluralNode, ResourceNode } from '../src/nodes'
 
 test('minify', () => {
   const parser = createParser({ location: false })
@@ -16,3 +18,14 @@ test('minify', () => {
     .filter(Boolean)
   expect(messages).toEqual(['no apples'])
 })
+
+test('unhandle error', () => {
+  // wrong node type
+  const type = 1024
+  const ast = {
+    type
+  } as unknown as ResourceNode
+  expect(() => minify(ast)).toThrowError(
+    format(errorMessages[CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE], type)
+  )
+})
diff --git a/packages/shared/src/error.ts b/packages/shared/src/error.ts
@@ -0,0 +1,3 @@
+export interface BaseError {
+  code: number
+}
diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.ts
@@ -1,3 +1,5 @@
 export * from './utils'
+export * from './warn'
+export * from './error'
 export * from './emittable'
 export * from './emitter'
diff --git a/packages/shared/src/utils.ts b/packages/shared/src/utils.ts
@@ -79,16 +79,6 @@ export const isRegExp = (val: unknown): val is RegExp =>
 export const isEmptyObject = (val: unknown): val is boolean =>
   isPlainObject(val) && Object.keys(val).length === 0
 
-export function warn(msg: string, err?: Error): void {
-  if (typeof console !== 'undefined') {
-    console.warn(`[intlify] ` + msg)
-    /* istanbul ignore if */
-    if (err) {
-      console.warn(err.stack)
-    }
-  }
-}
-
 export const assign = Object.assign
 
 let _globalThis: any
@@ -212,3 +202,8 @@ export function generateCodeFrame(
   }
   return res.join('\n')
 }
+
+export function incrementer(code: number): () => number {
+  let current = code
+  return () => ++current
+}
diff --git a/packages/shared/src/warn.ts b/packages/shared/src/warn.ts
@@ -0,0 +1,18 @@
+export function warn(msg: string, err?: Error): void {
+  if (typeof console !== 'undefined') {
+    console.warn(`[intlify] ` + msg)
+    /* istanbul ignore if */
+    if (err) {
+      console.warn(err.stack)
+    }
+  }
+}
+
+const hasWarned: Record<string, boolean> = {}
+
+export function warnOnce(msg: string) {
+  if (!hasWarned[msg]) {
+    hasWarned[msg] = true
+    warn(msg)
+  }
+}
diff --git a/packages/shared/test/utils.test.ts b/packages/shared/test/utils.test.ts
@@ -1,4 +1,10 @@
-import { format, generateCodeFrame, makeSymbol, join } from '../src/index'
+import {
+  format,
+  generateCodeFrame,
+  makeSymbol,
+  join,
+  incrementer
+} from '../src/index'
 
 test('format', () => {
   expect(format(`foo: {0}`, 'x')).toEqual('foo: x')
@@ -54,3 +60,13 @@ test('join', () => {
   ]
   expect(join(longSize, ' ')).toEqual(longSize.join(' '))
 })
+
+test('incrementer', () => {
+  const inc1 = incrementer(1)
+  const inc2 = incrementer(2)
+
+  expect(inc1()).toBe(2)
+  expect(inc1()).toBe(3)
+  expect(inc2()).toBe(3)
+  expect(inc2()).toBe(4)
+})
diff --git a/packages/vue-i18n-core/src/errors.ts b/packages/vue-i18n-core/src/errors.ts
diff --git a/packages/vue-i18n-core/src/warnings.ts b/packages/vue-i18n-core/src/warnings.ts

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+export interface BaseError {`
	`2`	`+ code: number`
	`3`	`+}`