2,360 matches across 25 files for error lang:TypeScript
snippet_mode: auto · sorted by relevance
11import {
12 CompilerDiagnostic,
13▶ CompilerError,
14 CompilerErrorDetail,
15 CompilerSuggestionOperation,
· · ·
14▶ CompilerErrorDetail,
15 CompilerSuggestionOperation,
16 ErrorCategory,
· · ·
16▶ ErrorCategory,
17} from '../CompilerError';
18import {assertExhaustive, hasNode} from '../Utils/utils';
· · ·
17▶} from '../CompilerError';
18import {assertExhaustive, hasNode} from '../Utils/utils';
19import {Environment} from './Environment';
· · ·
107 const binding = builder.resolveIdentifier(param);
108 if (binding.kind !== 'Identifier') {
109▶ builder.recordError(
110 CompilerDiagnostic.create({
111 category: ErrorCategory.Invariant,
+ 241 more matches in this file
8import {
9 CompilerDiagnostic,
10▶ CompilerError,
11 Effect,
12 SourceLocation,
· · ·
70 MutationReason,
71} from './AliasingEffects';
72▶import {ErrorCategory} from '../CompilerError';
73
74const DEBUG = false;
· · ·
93 * to the current abtract state, and effects may be dropped or rewritten accordingly.
94 * For example, a "MutateConditionally <x>" effect may be dropped if x is not a mutable
95▶ * value. A "Mutate <y>" effect may get converted into a "MutateFrozen <error>" effect
96 * if y is mutable, etc.
97 */
· · ·
132
133 if (fn.fnType === 'Component') {
134▶ CompilerError.invariant(fn.params.length <= 2, {
135 reason:
136 'Expected React component to have not more than two parameters: one for props and for ref',
· · ·
199 iterationCount++;
200 if (iterationCount > 100) {
201▶ CompilerError.invariant(false, {
202 reason: `[InferMutationAliasingEffects] Potential infinite loop`,
203 description: `A value, temporary place, or effect was not cached properly`,
+ 49 more matches in this file
8import {
9 CompilerDiagnostic,
10▶ CompilerError,
11 ErrorCategory,
12} from '../CompilerError';
· · ·
11▶ ErrorCategory,
12} from '../CompilerError';
13import {
· · ·
12▶} from '../CompilerError';
13import {
14 BlockId,
· · ·
35 *
36 * ```javascript
37▶ * // ERROR
38 * const ref = useRef();
39 * ref.current;
· · ·
55
56function makeRefId(id: number): RefId {
57▶ CompilerError.invariant(id >= 0 && Number.isInteger(id), {
58 reason: 'Expected identifier id to be a non-negative integer',
59 loc: GeneratedSource,
+ 75 more matches in this file
20
21type CompileSuccess = {kind: 'success'};
22▶type CompileParseError = {kind: 'parse_error'; message: string};
23type CompileErrors = {
24 kind: 'errors';
· · ·
23▶type CompileErrors = {
24 kind: 'errors';
25 errors: Array<{category: string; reason: string; description: string | null}>;
· · ·
24▶ kind: 'errors';
25 errors: Array<{category: string; reason: string; description: string | null}>;
26};
· · ·
25▶ errors: Array<{category: string; reason: string; description: string | null}>;
26};
27type CompileResult = CompileSuccess | CompileParseError | CompileErrors;
· · ·
27▶type CompileResult = CompileSuccess | CompileParseError | CompileErrors;
28
29/**
+ 32 more matches in this file
10import {
11 CompilerDiagnostic,
12▶ CompilerError,
13 CompilerErrorDetail,
14 ErrorCategory,
· · ·
13▶ CompilerErrorDetail,
14 ErrorCategory,
15} from '../CompilerError';
· · ·
14▶ ErrorCategory,
15} from '../CompilerError';
16import {CompileErrorDetail} from './Options';
· · ·
15▶} from '../CompilerError';
16import {CompileErrorDetail} from './Options';
17import {ExternalFunction, ReactFunctionType} from '../HIR/Environment';
· · ·
16▶import {CompileErrorDetail} from './Options';
17import {ExternalFunction, ReactFunctionType} from '../HIR/Environment';
18import {CodegenFunction} from '../ReactiveScopes';
+ 68 more matches in this file
15} from '.';
16import {
17▶ CompilerError,
18 CompilerErrorDetail,
19 ErrorCategory,
· · ·
18▶ CompilerErrorDetail,
19 ErrorCategory,
20} from '../CompilerError';
· · ·
19▶ ErrorCategory,
20} from '../CompilerError';
21import {Environment, ExternalFunction} from '../HIR';
· · ·
20▶} from '../CompilerError';
21import {Environment, ExternalFunction} from '../HIR';
22import {
· · ·
274 );
275 if (assertResult.isErr()) {
276▶ fn.env.recordErrors(assertResult.unwrapErr());
277 }
278 }
+ 62 more matches in this file
9import {
10 CompilerDiagnostic,
11▶ CompilerError,
12 CompilerSuggestionOperation,
13 Effect,
· · ·
14 SourceLocation,
15} from '..';
16▶import {CompilerSuggestion, ErrorCategory} from '../CompilerError';
17import {
18 areEqualPaths,
· · ·
65 * - If the value is non-reactive *and* a known stable type, then the
66 * value may optionally be specified as an exact dependency.
67▶ * - Otherwise, report an error unless there is a manual dependency that will
68 * invalidate whenever V invalidates. If `x.y.z` is referenced, there must
69 * be a manual dependency for `x.y.z`, `x.y`, or `x`. Note that we assume
· · ·
71 * always cause the other path to change as well.
72 * - Any dependencies that do not correspond to a value referenced in the memo
73▶ * function are considered extraneous and throw an error
74 *
75 * ## TODO: Invalid, Complex Deps
· · ·
110 locals: Set<IdentifierId>,
111 ): void {
112▶ CompilerError.invariant(startMemo == null, {
113 reason: 'Unexpected nested memo calls',
114 loc: value.loc,
+ 26 more matches in this file
208 const scope = scopeManager.acquire(node);
209 if (!scope) {
210▶ throw new Error(
211 'Unable to acquire scope for the current node. This is a bug in eslint-plugin-react-hooks, please file an issue.',
212 );
· · ·
229 if (
230 currentScope.type === 'function' ||
231▶ // @ts-expect-error incorrect TS types
232 currentScope.type === 'hook' ||
233 // @ts-expect-error incorrect TS types
· · ·
233▶ // @ts-expect-error incorrect TS types
234 currentScope.type === 'component'
235 ) {
· · ·
339 ) {
340 for (const ref of resolved.references) {
341▶ // @ts-expect-error These types are not compatible (Reference and Identifier)
342 if (ref !== id) {
343 useEffectEventVariables.add(ref.identifier);
· · ·
566 // Ignore Flow type parameters
567 if (
568▶ // @ts-expect-error We don't have flow types
569 def.type === 'TypeParameter' ||
570 // @ts-expect-error Flow-specific AST node type
+ 19 more matches in this file
114import {validateNoFreezingKnownMutableFunctions} from '../packages/babel-plugin-react-compiler/src/Validation/ValidateNoFreezingKnownMutableFunctions';
115
116▶import {CompilerError} from '../packages/babel-plugin-react-compiler/src/CompilerError';
117import {type HIRFunction} from '../packages/babel-plugin-react-compiler/src/HIR/HIR';
118
· · ·
125import {debugPrintHIR} from './debug-print-hir.mjs';
126import {debugPrintReactive} from './debug-print-reactive.mjs';
127▶import {debugPrintError} from './debug-print-error.mjs';
128
129// --- Arguments ---
· · ·
131
132if (!passArg || !fixturePath) {
133▶ console.error(
134 'Usage: npx tsx compiler/scripts/ts-compile-fixture.mjs <pass> <fixture-path>',
135 );
· · ·
188
189if (!VALID_PASSES.has(passArg)) {
190▶ console.error(`Unknown pass: ${passArg}`);
191 console.error(`Valid passes: ${[...VALID_PASSES].join(', ')}`);
192 process.exit(1);
· · ·
191▶ console.error(`Valid passes: ${[...VALID_PASSES].join(', ')}`);
192 process.exit(1);
193}
+ 39 more matches in this file
6 */
7
8▶import {CompilerError} from '../CompilerError';
9import {
10 BasicBlock,
· · ·
110 loc: SourceLocation,
111 ): {block: BlockId; place: Place; value: ReactiveValue; id: InstructionId} {
112▶ CompilerError.invariant(instructions.length !== 0, {
113 reason: `Expected non-empty instructions in extractValueBlockResult`,
114 description: null,
· · ·
204
205 visitBlock(block: BasicBlock, blockValue: ReactiveBlock): void {
206▶ CompilerError.invariant(!this.cx.emitted.has(block.id), {
207 reason: `Cannot emit the same block twice: bb${block.id}`,
208 loc: GeneratedSource,
· · ·
263 let consequent: ReactiveBlock | null = null;
264 if (this.cx.isScheduled(terminal.consequent)) {
265▶ CompilerError.invariant(false, {
266 reason: `Unexpected 'if' where the consequent is already scheduled`,
267 loc: terminal.loc,
· · ·
276 if (alternateId !== null) {
277 if (this.cx.isScheduled(alternateId)) {
278▶ CompilerError.invariant(false, {
279 reason: `Unexpected 'if' where the alternate is already scheduled`,
280 loc: terminal.loc,
+ 25 more matches in this file
7
8import * as t from '@babel/types';
9▶import {CompilerErrorDetail, ErrorCategory} from '../CompilerError';
10import {computeUnconditionalBlocks} from '../HIR/ComputeUnconditionalBlocks';
11import {Environment, isHookName} from '../HIR/Environment';
· · ·
31enum Kind {
32 // A potential/known hook which was already used in an invalid way
33▶ Error = 'Error',
34
35 /*
· · ·
60
61function joinKinds(a: Kind, b: Kind): Kind {
62▶ if (a === Kind.Error || b === Kind.Error) {
63 return Kind.Error;
64 } else if (a === Kind.KnownHook || b === Kind.KnownHook) {
· · ·
63▶ return Kind.Error;
64 } else if (a === Kind.KnownHook || b === Kind.KnownHook) {
65 return Kind.KnownHook;
· · ·
87 const unconditionalBlocks = computeUnconditionalBlocks(fn);
88
89▶ const errorsByPlace = new Map<t.SourceLocation, CompilerErrorDetail>();
90
91 function trackError(
+ 43 more matches in this file
6 */
7
8▶import {CompilerError, SourceLocation} from '..';
9import {
10 BlockId,
· · ·
109 let index = 0;
110
111▶ const shouldRecordErrors = !isFunctionExpression && fn.env.enableValidations;
112
113 for (const param of [...fn.params, ...fn.context, fn.returns]) {
· · ·
202 effect.kind === 'Impure'
203 ) {
204▶ if (shouldRecordErrors) {
205 fn.env.recordError(effect.error);
206 }
· · ·
205▶ fn.env.recordError(effect.error);
206 }
207 functionEffects.push(effect);
· · ·
231 state.assign(index++, effect.from, effect.into);
232 } else {
233▶ CompilerError.invariant(effect.kind === 'Freeze', {
234 reason: `Unexpected '${effect.kind}' effect for MaybeThrow terminal`,
235 loc: block.terminal.loc,
+ 9 more matches in this file
22// < 19.
23export const c =
24▶ // @ts-expect-error
25 typeof React.__COMPILER_RUNTIME?.c === 'function'
26 ? // @ts-expect-error
· · ·
26▶ ? // @ts-expect-error
27 React.__COMPILER_RUNTIME.c
28 : function c(size: number) {
· · ·
65].forEach(name => {
66 LazyGuardDispatcher[name] = () => {
67▶ throw new Error(
68 `[React] Unexpected React hook call (${name}) from a React compiled function. ` +
69 "Check that all hooks are called directly and named according to convention ('use[A-Z]') ",
· · ·
77LazyGuardDispatcher['useMemoCache'] = (count: number) => {
78 if (originalDispatcher == null) {
79▶ throw new Error(
80 'React Compiler internal invariant violation: unexpected null dispatcher',
81 );
· · ·
137 const curr = ReactSecretInternals.ReactCurrentDispatcher.current;
138 if (kind === GuardKind.PushGuardContext) {
139▶ // Push before checking invariant or errors
140 guardFrames.push(curr);
141
+ 32 more matches in this file
11 * Given a configuration module and a source root directory, compiles files
12 * using the exact plugin options from the configuration, then compares code
13▶ * output and error events between the TS and Rust compilers. Files with
14 * differences can be copied as test fixtures for further investigation.
15 *
· · ·
65
66if (positional.length < 2) {
67▶ console.error(
68 'Usage: npx tsx compiler/scripts/test-internal-files.ts <config-path> <source-root> [flags]',
69 );
· · ·
70▶ console.error('');
71 console.error('Arguments:');
72 console.error(' <config-path> Path to the compiler configuration module');
· · ·
71▶ console.error('Arguments:');
72 console.error(' <config-path> Path to the compiler configuration module');
73 console.error(
· · ·
72▶ console.error(' <config-path> Path to the compiler configuration module');
73 console.error(
74 ' <source-root> Root directory for resolving config source prefixes',
+ 40 more matches in this file
7
8import * as t from '@babel/types';
9▶import {ZodError, z} from 'zod/v4';
10import {fromZodError} from 'zod-validation-error/v4';
11import {
· · ·
10▶import {fromZodError} from 'zod-validation-error/v4';
11import {
12 CompilerDiagnostic,
· · ·
13▶ CompilerError,
14 CompilerErrorDetail,
15 ErrorCategory,
· · ·
14▶ CompilerErrorDetail,
15 ErrorCategory,
16} from '../CompilerError';
· · ·
15▶ ErrorCategory,
16} from '../CompilerError';
17import {
+ 59 more matches in this file
7
8import {Result} from '../Utils/Result';
9▶import {CompilerDiagnostic, CompilerError, Effect} from '..';
10import {ErrorCategory} from '../CompilerError';
11import {
· · ·
10▶import {ErrorCategory} from '../CompilerError';
11import {
12 BlockId,
· · ·
46 readonly functions: Map<IdentifierId, FunctionExpression>;
47 readonly candidateDependencies: Map<IdentifierId, ArrayExpression>;
48▶ readonly errors: CompilerError;
49 readonly derivationCache: DerivationCache;
50 readonly effectsCache: Map<IdentifierId, EffectMetadata>;
· · ·
183export function validateNoDerivedComputationsInEffects_exp(
184 fn: HIRFunction,
185▶): Result<void, CompilerError> {
186 const functions: Map<IdentifierId, FunctionExpression> = new Map();
187 const candidateDependencies: Map<IdentifierId, ArrayExpression> = new Map();
· · ·
188 const derivationCache = new DerivationCache();
189▶ const errors = new CompilerError();
190 const effectsCache: Map<IdentifierId, EffectMetadata> = new Map();
191
+ 8 more matches in this file
9import * as t from '@babel/types';
10import {
11▶ CompilerError,
12 CompilerDiagnostic,
13 CompilerErrorDetail,
· · ·
13▶ CompilerErrorDetail,
14 ErrorCategory,
15} from '../CompilerError';
· · ·
14▶ ErrorCategory,
15} from '../CompilerError';
16import {Environment} from './Environment';
· · ·
15▶} from '../CompilerError';
16import {Environment} from './Environment';
17import {
· · ·
96 /*
97 * Mode used for code not covered by explicit exception handling, any
98▶ * errors are assumed to be thrown out of the function
99 */
100 | {kind: 'ThrowExceptions'}
+ 21 more matches in this file
19} from 'estree';
20
21▶// @ts-expect-error untyped module
22import CodePathAnalyzer from '../code-path-analysis/code-path-analyzer';
23import {getAdditionalEffectHooksFromSettings} from '../shared/Utils';
· · ·
172}
173
174▶function useEffectEventError(fn: string | null, called: boolean): string {
175 // no function identifier, i.e. it is not assigned to a variable
176 if (fn === null) {
· · ·
239 ) {
240 if (reference.resolved === null) {
241▶ throw new Error('Unexpected null reference.resolved');
242 }
243 for (const ref of reference.resolved.references) {
· · ·
309 return;
310 } else if (typeof reactHooksMap === 'undefined') {
311▶ throw new Error('Unexpected undefined reactHooksMap');
312 }
313
· · ·
523 // `undefined` then we know either that we have an anonymous function
524 // expression or our code path is not in a function. In both cases we
525▶ // will want to error since neither are React function components or
526 // hook functions - unless it is an anonymous function argument to
527 // forwardRef or memo.
+ 14 more matches in this file
1▶import {CompilerError, SourceLocation} from '..';
2import {
3 Environment,
· · ·
8} from '../HIR';
9import * as t from '@babel/types';
10▶import * as TypeErrors from './TypeErrors';
11import {assertExhaustive} from '../Utils/utils';
12import {FlowType} from './FlowTypes';
· · ·
150
151export function makeLinearId(id: number): LinearId {
152▶ CompilerError.invariant(id >= 0 && Number.isInteger(id), {
153 reason: 'Expected LinearId id to be a non-negative integer',
154 loc: GeneratedSource,
· · ·
163
164export function makeTypeParameterId(id: number): TypeParameterId {
165▶ CompilerError.invariant(id >= 0 && Number.isInteger(id), {
166 reason: 'Expected TypeParameterId to be a non-negative integer',
167 loc: GeneratedSource,
· · ·
185
186export function makeVariableId(id: number): VariableId {
187▶ CompilerError.invariant(id >= 0 && Number.isInteger(id), {
188 reason: 'Expected VariableId id to be a non-negative integer',
189 loc: GeneratedSource,
+ 11 more matches in this file
1import {GeneratedSource} from '../HIR';
2import {assertExhaustive} from '../Utils/utils';
3▶import {unsupportedLanguageFeature} from './TypeErrors';
4import {
5 ConcreteType,
· · ·
151 init: R,
152): R {
153▶ let errors = init;
154
155 // Check if kinds match
· · ·
156 if (a.kind !== b.kind) {
157▶ errors = onMismatch(a, b, errors);
158 return errors;
159 }
· · ·
158▶ return errors;
159 }
160
· · ·
171 case 'Nullable':
172 // Check the nested type
173▶ errors = onChildMismatch(onChild(a.type, (b as typeof a).type), errors);
174 break;
175
+ 21 more matches in this file
8import {
9 CompilerDiagnostic,
10▶ CompilerError,
11 ErrorCategory,
12} from '../CompilerError';
· · ·
11▶ ErrorCategory,
12} from '../CompilerError';
13import {
· · ·
12▶} from '../CompilerError';
13import {
14 DeclarationId,
· · ·
69 */
70 reassignments: Map<DeclarationId, Set<Identifier>>;
71▶ // The source of the original memoization, used when reporting errors
72 loc: SourceLocation;
73
· · ·
243 };
244 } else {
245▶ CompilerError.invariant(dep.identifier.name?.kind === 'named', {
246 reason:
247 'ValidatePreservedManualMemoization: expected scope dependency to be named',
+ 18 more matches in this file
29 );
30 if (!configPath) {
31▶ throw new Error("Could not find a valid 'tsconfig.json'.");
32 }
33 const createProgram = ts.createSemanticDiagnosticsBuilderProgram;
· · ·
37 ts.sys,
38 createProgram,
39▶ () => {}, // we manually report errors in afterProgramCreate
40 () => {}, // we manually report watch status
41 );
· · ·
53
54 // syntactic diagnostics refer to javascript syntax
55▶ const errors = program
56 .getSyntacticDiagnostics()
57 .filter(diag => diag.category === ts.DiagnosticCategory.Error);
· · ·
57▶ .filter(diag => diag.category === ts.DiagnosticCategory.Error);
58 // semantic diagnostics refer to typescript semantics
59 errors.push(
· · ·
59▶ errors.push(
60 ...program
61 .getSemanticDiagnostics()
+ 15 more matches in this file
108 });
109} catch (e: any) {
110▶ // Show stderr on build failure (includes errors + warnings)
111 if (e.stderr) {
112 process.stderr.write(e.stderr);
· · ·
113 }
114▶ console.error(`${RED}ERROR: Failed to build Rust crates.${RESET}`);
115 process.exit(1);
116}
· · ·
130
131if (!fs.existsSync(dylib)) {
132▶ console.error(
133 `${RED}ERROR: Could not find built native module in ${TARGET_DIR}${RESET}`,
134 );
· · ·
133▶ `${RED}ERROR: Could not find built native module in ${TARGET_DIR}${RESET}`,
134 );
135 process.exit(1);
· · ·
170type CompileResult = {
171 code: string | null;
172▶ error: string | null;
173 events: Array<Record<string, unknown>>;
174};
+ 14 more matches in this file
6 */
7
8▶import {CompilerDiagnostic, CompilerError, SourceLocation} from '..';
9import {ErrorCategory} from '../CompilerError';
10import {
· · ·
9▶import {ErrorCategory} from '../CompilerError';
10import {
11 CallExpression,
· · ·
304 >;
305 if (fnPlace == null || fnPlace.kind !== 'Identifier') {
306▶ env.recordError(
307 CompilerDiagnostic.create({
308 category: ErrorCategory.UseMemo,
· · ·
308▶ category: ErrorCategory.UseMemo,
309 reason: `Expected a callback function to be passed to ${kind}`,
310 description:
· · ·
314 suggestions: null,
315 }).withDetails({
316▶ kind: 'error',
317 loc: instr.value.loc,
318 message:
+ 10 more matches in this file
26import type {Type} from './Types';
27import type {AliasingEffect} from '../Inference/AliasingEffects';
28▶import type {CompilerDiagnostic, CompilerErrorDetail} from '../CompilerError';
29import type {IdentifierId, ScopeId} from './HIR';
30
· · ·
42 printer.line('Environment:');
43 printer.indent();
44▶ const errors = fn.env.aggregateErrors();
45 printer.formatErrors(errors);
46 printer.dedent();
· · ·
45▶ printer.formatErrors(errors);
46 printer.dedent();
47
· · ·
1250 return `MutateTransitiveConditionally { value: ${effect.value.identifier.id} }`;
1251 case 'MutateFrozen':
1252▶ return `MutateFrozen { place: ${effect.place.identifier.id}, reason: ${JSON.stringify(effect.error.reason)} }`;
1253 case 'MutateGlobal':
1254 return `MutateGlobal { place: ${effect.place.identifier.id}, reason: ${JSON.stringify(effect.error.reason)} }`;
· · ·
1254▶ return `MutateGlobal { place: ${effect.place.identifier.id}, reason: ${JSON.stringify(effect.error.reason)} }`;
1255 case 'Impure':
1256 return `Impure { place: ${effect.place.identifier.id}, reason: ${JSON.stringify(effect.error.reason)} }`;
+ 7 more matches in this file