ucn 5.5.1 → 5.5.3

package/languages/java-platform.js

@@ -0,0 +1,226 @@
+'use strict';
+
+/**
+ * languages/java-platform.js - JDK contracts the Java overload, conversion
+ * and receiver rules read (fix #421: moved out of core/callers.js). Each
+ * table is a specification-level fact of the Java platform (JLS conversions,
+ * final value types, java.lang interface members, factory return types), not
+ * knowledge about any project. A platform type outside these tables has
+ * unknown members and supertypes: the engine's answer through it stays open
+ * (unverified with a reason), never closed by assumption.
+ */
+
+const JAVA_FINAL_REFERENCE_TYPES = new Set([
+    'String', 'Class', 'Boolean', 'Byte', 'Character', 'Short',
+    'Integer', 'Long', 'Float', 'Double', 'Void',
+]);
+
+// Complete reference-supertype sets for JDK value types (fix #299D): these
+// types are final (or effectively closed) with a fixed, fully-known
+// ancestry, so an argument statically typed as one of them can bind ONLY a
+// parameter type in this list (plus Object/generics, handled earlier). A
+// project class shadowing one of these simple names disables the denial —
+// the guard is tDefs.length === 0 at the use site. Modern-JDK marker
+// interfaces (Constable, ConstantDesc) are included so their params never
+// get falsely denied.
+const JAVA_PLATFORM_VALUE_ANCESTRY = new Map([
+    ['Integer', ['Number', 'Comparable', 'Serializable', 'Constable', 'ConstantDesc']],
+    ['Long', ['Number', 'Comparable', 'Serializable', 'Constable', 'ConstantDesc']],
+    ['Short', ['Number', 'Comparable', 'Serializable', 'Constable', 'ConstantDesc']],
+    ['Byte', ['Number', 'Comparable', 'Serializable', 'Constable', 'ConstantDesc']],
+    ['Float', ['Number', 'Comparable', 'Serializable', 'Constable', 'ConstantDesc']],
+    ['Double', ['Number', 'Comparable', 'Serializable', 'Constable', 'ConstantDesc']],
+    ['Character', ['Comparable', 'Serializable', 'Constable']],
+    ['Boolean', ['Comparable', 'Serializable', 'Constable']],
+    ['String', ['CharSequence', 'Comparable', 'Serializable', 'Constable', 'ConstantDesc']],
+    ['BigInteger', ['Number', 'Comparable', 'Serializable']],
+    ['BigDecimal', ['Number', 'Comparable', 'Serializable']],
+]);
+
+// Unboxing is defined for exactly these wrapper types (JLS 5.1.8).
+const JAVA_WRAPPER_PRIMITIVES = new Map([
+    ['Integer', 'int'], ['Long', 'long'], ['Short', 'short'], ['Byte', 'byte'],
+    ['Character', 'char'], ['Boolean', 'boolean'],
+    ['Float', 'float'], ['Double', 'double'],
+]);
+
+// Declared types of the JDK numeric-constant fields (fix #299D): exact
+// compiler contracts, consulted only when no project field shadows the
+// owner/field pair.
+const JAVA_PLATFORM_FIELD_TYPES = new Map([
+    ['Float.NaN', 'float'], ['Float.POSITIVE_INFINITY', 'float'],
+    ['Float.NEGATIVE_INFINITY', 'float'], ['Float.MIN_VALUE', 'float'],
+    ['Float.MAX_VALUE', 'float'], ['Float.MIN_NORMAL', 'float'],
+    ['Double.NaN', 'double'], ['Double.POSITIVE_INFINITY', 'double'],
+    ['Double.NEGATIVE_INFINITY', 'double'], ['Double.MIN_VALUE', 'double'],
+    ['Double.MAX_VALUE', 'double'], ['Double.MIN_NORMAL', 'double'],
+    ['Integer.MAX_VALUE', 'int'], ['Integer.MIN_VALUE', 'int'],
+    ['Long.MAX_VALUE', 'long'], ['Long.MIN_VALUE', 'long'],
+    ['Short.MAX_VALUE', 'short'], ['Short.MIN_VALUE', 'short'],
+    ['Byte.MAX_VALUE', 'byte'], ['Byte.MIN_VALUE', 'byte'],
+    ['Character.MAX_VALUE', 'char'], ['Character.MIN_VALUE', 'char'],
+    ['Boolean.TRUE', 'Boolean'], ['Boolean.FALSE', 'Boolean'],
+]);
+
+// Small, authoritative platform surface used only when the parser preserved
+// the imported owner. These are JDK interface/method declarations, not
+// name-based guesses. They close the common portable-AST gap where overload
+// resolution depends on the return type of a library call.
+const JAVA_PLATFORM_METHOD_RETURNS = new Map([
+    // Exact JDK factory contracts (fix #299D): valueOf on the boxed and
+    // arbitrary-precision types returns the owner type itself.
+    ['java.math.BigInteger#valueOf', 'java.math.BigInteger'],
+    ['java.math.BigDecimal#valueOf', 'java.math.BigDecimal'],
+    ['java.lang.Integer#valueOf', 'java.lang.Integer'],
+    ['java.lang.Long#valueOf', 'java.lang.Long'],
+    ['java.lang.Short#valueOf', 'java.lang.Short'],
+    ['java.lang.Byte#valueOf', 'java.lang.Byte'],
+    ['java.lang.Float#valueOf', 'java.lang.Float'],
+    ['java.lang.Double#valueOf', 'java.lang.Double'],
+    ['java.lang.Boolean#valueOf', 'java.lang.Boolean'],
+    ['java.lang.Character#valueOf', 'java.lang.Character'],
+    ['java.lang.String#valueOf', 'java.lang.String'],
+    ['java.lang.Object#getClass', 'java.lang.Class'],
+    ['java.lang.Class#getEnclosingClass', 'java.lang.Class'],
+    ['java.lang.Class#getDeclaringClass', 'java.lang.Class'],
+    ['java.lang.Class#getDeclaredMethod', 'java.lang.reflect.Method'],
+    ['java.lang.Enum#getDeclaringClass', 'java.lang.Class'],
+    ['java.lang.reflect.Method#getReturnType', 'java.lang.Class'],
+    ['java.lang.reflect.Constructor#getDeclaringClass', 'java.lang.Class'],
+    ['java.lang.annotation.Annotation#annotationType', 'java.lang.Class'],
+    ['java.lang.reflect.Method#getGenericReturnType', 'java.lang.reflect.Type'],
+    ['java.lang.reflect.Method#getParameterTypes', 'java.lang.Class[]'],
+    ['java.lang.reflect.Method#getGenericParameterTypes', 'java.lang.reflect.Type[]'],
+    ['javax.lang.model.element.Element#asType', 'javax.lang.model.type.TypeMirror'],
+    ['javax.lang.model.element.TypeElement#asType', 'javax.lang.model.type.TypeMirror'],
+    ['javax.lang.model.element.TypeParameterElement#asType', 'javax.lang.model.type.TypeMirror'],
+    ['javax.lang.model.element.VariableElement#asType', 'javax.lang.model.type.TypeMirror'],
+    ['javax.lang.model.element.ExecutableElement#asType', 'javax.lang.model.type.TypeMirror'],
+    ['javax.lang.model.element.ExecutableElement#getReturnType', 'javax.lang.model.type.TypeMirror'],
+    ['javax.lang.model.element.AnnotationMirror#getElementValues', 'java.util.Map'],
+    ['javax.lang.model.element.Element#getAnnotationMirrors', 'java.util.List'],
+    ['javax.lang.model.element.TypeElement#getAnnotationMirrors', 'java.util.List'],
+    ['javax.lang.model.element.TypeElement#getEnclosedElements', 'java.util.List'],
+    ['javax.lang.model.element.ExecutableElement#getParameters', 'java.util.List'],
+    ['javax.lang.model.util.ElementFilter#methodsIn', 'java.util.List'],
+    ['javax.lang.model.util.Types#getPrimitiveType', 'javax.lang.model.type.PrimitiveType'],
+    ['javax.lang.model.util.Types#getArrayType', 'javax.lang.model.type.ArrayType'],
+    ['javax.lang.model.util.Types#getDeclaredType', 'javax.lang.model.type.DeclaredType'],
+    ['javax.lang.model.util.Types#getWildcardType', 'javax.lang.model.type.WildcardType'],
+    ['javax.lang.model.util.Types#getNoType', 'javax.lang.model.type.NoType'],
+    ['javax.lang.model.util.Types#getNullType', 'javax.lang.model.type.NullType'],
+    // JDK collection factories (fix #428): `with(Arrays.asList(..))` passes a
+    // List, never the element type of a sibling varargs overload.
+    ['java.util.Arrays#asList', 'java.util.List'],
+    ['java.util.List#of', 'java.util.List'], ['java.util.List#copyOf', 'java.util.List'],
+    ['java.util.Set#of', 'java.util.Set'], ['java.util.Set#copyOf', 'java.util.Set'],
+    ['java.util.Map#of', 'java.util.Map'], ['java.util.Map#copyOf', 'java.util.Map'],
+    ['java.util.Collections#emptyList', 'java.util.List'], ['java.util.Collections#singletonList', 'java.util.List'],
+    ['java.util.Collections#unmodifiableList', 'java.util.List'],
+    ['java.util.Collections#emptySet', 'java.util.Set'], ['java.util.Collections#singleton', 'java.util.Set'],
+    ['java.util.Collections#unmodifiableSet', 'java.util.Set'],
+    ['java.util.Collections#emptyMap', 'java.util.Map'], ['java.util.Collections#singletonMap', 'java.util.Map'],
+    ['java.util.Collections#unmodifiableMap', 'java.util.Map'],
+]);
+
+// Complete inherited member-name surfaces of these JDK contracts. None declares
+// a member type. A contract is usable only after the written supertype has
+// resolved to this qualified SDK identity; an external namesake is unknown.
+const JAVA_PLATFORM_ANCESTOR_MEMBERS = new Map([
+    ['java.lang.Object', new Set(['getClass', 'hashCode', 'equals', 'clone',
+        'toString', 'notify', 'notifyAll', 'wait', 'finalize'])],
+    ['java.lang.Comparable', new Set(['compareTo'])],
+    ['java.lang.Iterable', new Set(['iterator', 'forEach', 'spliterator'])],
+    ['java.lang.AutoCloseable', new Set(['close'])],
+    ['java.io.Closeable', new Set(['close'])],
+    ['java.util.Map.Entry', new Set(['getKey', 'getValue', 'setValue', 'equals', 'hashCode'])],
+    ['java.lang.Runnable', new Set(['run'])],
+    ['java.lang.Cloneable', new Set()],
+    ['java.io.Serializable', new Set()],
+]);
+
+const JAVA_PLATFORM_SUPERTYPES = new Map([
+    ['java.lang.reflect.Type', ['java.lang.Object']],
+    ['java.lang.reflect.ParameterizedType', ['java.lang.Object', 'java.lang.reflect.Type']],
+    ['java.lang.reflect.GenericArrayType', ['java.lang.Object', 'java.lang.reflect.Type']],
+    ['java.lang.reflect.TypeVariable', ['java.lang.Object', 'java.lang.reflect.Type',
+        'java.lang.reflect.AnnotatedElement']],
+    ['java.lang.reflect.WildcardType', ['java.lang.Object', 'java.lang.reflect.Type']],
+    ['java.lang.Class', ['java.lang.Object', 'java.lang.reflect.Type', 'java.io.Serializable',
+        'java.lang.reflect.GenericDeclaration', 'java.lang.reflect.AnnotatedElement',
+        'java.lang.invoke.TypeDescriptor.OfField', 'java.lang.invoke.TypeDescriptor',
+        'java.lang.constant.Constable']],
+    ['javax.lang.model.type.ArrayType', ['javax.lang.model.type.ReferenceType',
+        'javax.lang.model.type.TypeMirror']],
+    ['javax.lang.model.type.DeclaredType', ['javax.lang.model.type.ReferenceType',
+        'javax.lang.model.type.TypeMirror']],
+    ['javax.lang.model.type.ErrorType', ['javax.lang.model.type.DeclaredType',
+        'javax.lang.model.type.ReferenceType', 'javax.lang.model.type.TypeMirror']],
+    ['javax.lang.model.type.ExecutableType', ['javax.lang.model.type.TypeMirror']],
+    ['javax.lang.model.type.IntersectionType', ['javax.lang.model.type.TypeMirror']],
+    ['javax.lang.model.type.NoType', ['javax.lang.model.type.TypeMirror']],
+    ['javax.lang.model.type.NullType', ['javax.lang.model.type.ReferenceType',
+        'javax.lang.model.type.TypeMirror']],
+    ['javax.lang.model.type.PrimitiveType', ['javax.lang.model.type.TypeMirror']],
+    ['javax.lang.model.type.TypeVariable', ['javax.lang.model.type.ReferenceType',
+        'javax.lang.model.type.TypeMirror']],
+    ['javax.lang.model.type.UnionType', ['javax.lang.model.type.TypeMirror']],
+    ['javax.lang.model.type.WildcardType', ['javax.lang.model.type.TypeMirror']],
+    // JDK collections (fix #391): their declared supertypes, so a
+    // `new LinkedHashMap<>()` argument proves a Map parameter applicable.
+    ...[
+        ['ArrayList', ['List', 'Collection', 'Iterable', 'RandomAccess', 'AbstractList',
+            'AbstractCollection', 'SequencedCollection', 'Cloneable', 'Serializable']],
+        ['LinkedList', ['List', 'Deque', 'Queue', 'Collection', 'Iterable', 'AbstractSequentialList',
+            'AbstractList', 'AbstractCollection', 'SequencedCollection', 'Cloneable', 'Serializable']],
+        ['ArrayDeque', ['Deque', 'Queue', 'Collection', 'Iterable', 'AbstractCollection',
+            'SequencedCollection', 'Cloneable', 'Serializable']],
+        // The collection interfaces themselves (fix #428).
+        ['List', ['SequencedCollection', 'Collection', 'Iterable']],
+        ['Set', ['Collection', 'Iterable']],
+        ['Collection', ['Iterable']],
+        ['Map', []],
+        ['HashMap', ['Map', 'AbstractMap', 'Cloneable', 'Serializable']],
+        ['LinkedHashMap', ['HashMap', 'Map', 'SequencedMap', 'AbstractMap', 'Cloneable', 'Serializable']],
+        ['TreeMap', ['NavigableMap', 'SortedMap', 'SequencedMap', 'Map', 'AbstractMap', 'Cloneable',
+            'Serializable']],
+        ['HashSet', ['Set', 'Collection', 'Iterable', 'AbstractSet', 'AbstractCollection', 'Cloneable',
+            'Serializable']],
+        ['LinkedHashSet', ['HashSet', 'SequencedSet', 'SequencedCollection', 'Set', 'Collection', 'Iterable',
+            'AbstractSet', 'AbstractCollection', 'Cloneable', 'Serializable']],
+        ['TreeSet', ['NavigableSet', 'SortedSet', 'SequencedSet', 'SequencedCollection', 'Set', 'Collection',
+            'Iterable', 'AbstractSet', 'AbstractCollection', 'Cloneable', 'Serializable']],
+    ].map(([type, supertypes]) => [`java.util.${type}`, supertypes.map(name =>
+        (name === 'Iterable' || name === 'Cloneable' ? `java.lang.${name}`
+            : name === 'Serializable' ? 'java.io.Serializable' : `java.util.${name}`))]),
+]);
+
+const JAVA_MODELED_PLATFORM_TYPES = new Set([
+    ...JAVA_PLATFORM_ANCESTOR_MEMBERS.keys(),
+    ...JAVA_PLATFORM_METHOD_RETURNS.keys()].map(name => name.split('#')[0]));
+for (const type of JAVA_PLATFORM_METHOD_RETURNS.values()) JAVA_MODELED_PLATFORM_TYPES.add(type.replace(/\[\]$/, ''));
+for (const [type, parents] of JAVA_PLATFORM_SUPERTYPES) {
+    JAVA_MODELED_PLATFORM_TYPES.add(type);
+    for (const parent of parents) JAVA_MODELED_PLATFORM_TYPES.add(parent);
+}
+
+function platformAssignable(actualType, expectedSimple) {
+    if (!actualType?.includes('.')) return null;
+    const actualSimple = actualType.split('.').pop();
+    if (actualSimple === expectedSimple) return true;
+    const known = JAVA_PLATFORM_SUPERTYPES.get(actualType);
+    if (known) return known.some(type => type.split('.').pop() === expectedSimple);
+    if (actualType === 'java.lang.Class') {
+        return ['Type', 'Serializable', 'GenericDeclaration', 'AnnotatedElement',
+            'Object'].includes(expectedSimple);
+    }
+    // An unmodeled actual type may implement any of these interfaces.
+    // Knowing only the expected type cannot disprove the conversion.
+    return null;
+}
+
+module.exports = {
+    JAVA_FINAL_REFERENCE_TYPES, JAVA_PLATFORM_VALUE_ANCESTRY, JAVA_WRAPPER_PRIMITIVES, JAVA_PLATFORM_FIELD_TYPES,
+    JAVA_PLATFORM_METHOD_RETURNS, JAVA_PLATFORM_ANCESTOR_MEMBERS, JAVA_PLATFORM_SUPERTYPES,
+    JAVA_MODELED_PLATFORM_TYPES, platformAssignable,
+};

package/languages/java-unicode.js

@@ -0,0 +1,269 @@
+'use strict';
+
+// Modules read lazily (load cycles), each resolved once: a require() per
+// call in hot paths was measurable (fix #436).
+let lazySourceMemoModuleCache = null;
+const lazySourceMemoModule = () => lazySourceMemoModuleCache || (lazySourceMemoModuleCache = require('../core/source-memo'));
+
+// Java translates eligible Unicode escapes before tokenization (JLS 3.3).
+// Keep this lexical step separate from name lookup and never rescan output.
+function translateUnicodeEscapes(source) {
+    if (!source.includes('\\u')) return source;
+    let result = '', backslashes = 0, escaped = false;
+    for (let i = 0; i < source.length;) {
+        let character = source[i++];
+        if (character === '\\' && (escaped || backslashes % 2 === 0) && source[i] === 'u') {
+            while (source[i] === 'u') i++;
+            let value = 0;
+            for (let digit = 0; digit < 4; digit++) {
+                const code = source.charCodeAt(i++);
+                const hex = code >= 48 && code <= 57 ? code - 48
+                    : code >= 65 && code <= 70 ? code - 55
+                        : code >= 97 && code <= 102 ? code - 87 : -1;
+                if (hex < 0) return null;
+                value = value * 16 + hex;
+            }
+            character = String.fromCharCode(value);
+            escaped = true;
+        } else escaped = false;
+        result += character;
+        backslashes = character === '\\' ? backslashes + 1 : 0;
+    }
+    return result;
+}
+
+// Identifier equality ignores these characters (JLS 3.8). An unassigned
+// character may belong to a newer compiler's Unicode table; abstain there.
+const NONCANONICAL_IDENTIFIER = /[\p{Cf}\p{Cn}]/u;
+const LITERAL_PARTS = new Set(['string_fragment', 'multiline_string_fragment', 'escape_sequence']);
+
+function noncanonicalIdentifier(text) {
+    if (NONCANONICAL_IDENTIFIER.test(text)) return true;
+    for (const character of text) {
+        const code = character.charCodeAt(0);
+        if (code <= 8 || code >= 14 && code <= 27 || code >= 127 && code <= 159) return true;
+    }
+    return false;
+}
+
+function typeNameStructure(tree) {
+    if (!tree || tree.rootNode.hasError) return null;
+    const tokens = [], stack = [tree.rootNode];
+    while (stack.length) {
+        const node = stack.pop();
+        if (node.isMissing) return null;
+        if (node.type === 'line_comment' || node.type === 'block_comment') continue;
+        tokens.push(node.type);
+        if (node.type === 'string_literal' || node.type === 'character_literal') {
+            if (node.namedChildren.some(child => !LITERAL_PARTS.has(child.type))) return null;
+            continue;
+        }
+        const children = node.children;
+        if (!children.length) {
+            if (noncanonicalIdentifier(node.text)) return null;
+            tokens.push(node.text);
+        } else {
+            tokens.push(children.length);
+            for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]);
+        }
+    }
+    return JSON.stringify(tokens);
+}
+
+// Verdicts by source text (the text is the key; see core/source-memo.js).
+const canonicalSources = new (require('../core/source-memo').BoundedMap)({ maxEntries: 1024,
+    maxWeight: 32 * 1024 * 1024, weigh: (_verdict, source) => source.length * 2 });
+
+function parseNameSource(parser, source, safeParse) {
+    // A NUL is legal literal/comment content, but the grammar cannot read it.
+    // Project it to an ordinary character, then prove every projected position
+    // lies inside that AST content. A NUL in a name or other code stays opaque.
+    const positions = [];
+    for (let i = source.indexOf('\0'); i !== -1; i = source.indexOf('\0', i + 1)) positions.push(i);
+    const tree = safeParse(parser, positions.length ? source.replaceAll('\0', 'x') : source);
+    if (!tree) return null;
+    for (const position of positions) {
+        let node = tree.rootNode.descendantForIndex(position, position + 1);
+        while (node && !['string_literal', 'character_literal', 'line_comment', 'block_comment'].includes(node.type)) {
+            node = node.parent;
+        }
+        const contentStart = node?.type.endsWith('comment') ? node.startIndex + 2 : node?.startIndex + 1;
+        const contentEnd = node?.type === 'line_comment' ? node.endIndex
+            : node?.type === 'block_comment' ? node.endIndex - 2 : node?.endIndex - 1;
+        if (!node || position < contentStart || position >= contentEnd) {
+            tree.delete?.();
+            return null;
+        }
+    }
+    return tree;
+}
+
+// typeNameStructure(tree) !== null for a source with no character a
+// noncanonical identifier test could reject: an error-free tree (MISSING
+// nodes count as errors) whose literals hold only literal parts. The full
+// token walk serves the other sources (fix #418: it walked every node of
+// every Java file an overload check read).
+function plainStructure(tree, source) {
+    if (!tree || tree.rootNode.hasError) return false;
+    if (noncanonicalIdentifier(source)) return typeNameStructure(tree) !== null;
+    return tree.rootNode.descendantsOfType(['string_literal', 'character_literal'])
+        .every(node => node.namedChildren.every(child => LITERAL_PARTS.has(child.type)));
+}
+
+// Equal code between corresponding literal/comment regions has the same
+// token stream, including extra comment nodes. Java's grammar does not read
+// their contents as code. Check both trees and literal children so an escape
+// that ends a region or introduces a template cannot use this proof.
+function literalOnlyTranslation(rawTree, translatedTree, source, translated) {
+    if (!rawTree || !translatedTree || rawTree.rootNode.hasError || translatedTree.rootNode.hasError) return false;
+    const kinds = ['string_literal', 'character_literal', 'line_comment', 'block_comment'];
+    const before = rawTree.rootNode.descendantsOfType(kinds);
+    const after = translatedTree.rootNode.descendantsOfType(kinds);
+    if (before.length !== after.length) return false;
+    let rawEnd = 0, translatedEnd = 0;
+    for (let i = 0; i < before.length; i++) {
+        const left = before[i], right = after[i];
+        if (left.type !== right.type || left.startIndex < rawEnd || right.startIndex < translatedEnd) return false;
+        const outside = source.slice(rawEnd, left.startIndex);
+        if (outside !== translated.slice(translatedEnd, right.startIndex) || noncanonicalIdentifier(outside)) return false;
+        if (left.type === 'string_literal' || left.type === 'character_literal') {
+            if (left.namedChildren.some(child => !LITERAL_PARTS.has(child.type)) ||
+                right.namedChildren.some(child => !LITERAL_PARTS.has(child.type))) return false;
+        }
+        rawEnd = left.endIndex;
+        translatedEnd = right.endIndex;
+    }
+    const outside = source.slice(rawEnd);
+    return outside === translated.slice(translatedEnd) && !noncanonicalIdentifier(outside);
+}
+
+// The index retains raw-source positions. Its type/name facts are usable
+// when lexical translation preserves the AST's names and structure. Literal
+// contents and comment text do not change Java's static argument types.
+// `parseError` (a value or a function giving it) is whether the index's
+// parse of this same content had errors, when known (fix #418): an
+// error-free source with no escape, no string template and no character an
+// identifier test could reject is canonical without a second parse; a source
+// with errors never is.
+function typeNameSourceCanonical(source, parseError = undefined, lines = null) {
+    if (typeof source !== 'string') return false;
+    if (wholeSourceCanonical(source, parseError)) return true;
+    if (!lines) return false;
+    // A parse error confined to member declarations leaves the names of
+    // every other member as the index read them (fix #421): one unrelated
+    // syntax error demoted every overload choice of its file.
+    const scopes = errorMemberScopes(source);
+    return !!scopes && !scopes.some(([start, end]) => start <= lines.endLine && lines.startLine <= end);
+}
+
+function wholeSourceCanonical(source, parseError) {
+    const saved = canonicalSources.get(source);
+    if (saved !== undefined) return saved;
+    const indexed = typeof parseError === 'function' ? parseError() : parseError;
+    let canonical = false;
+    if (indexed === true) canonical = false;
+    else if (indexed === false && !source.includes('\\u') && !source.includes('\\{') &&
+        !noncanonicalIdentifier(source)) canonical = true;
+    else {
+        const translated = translateUnicodeEscapes(source);
+        if (translated !== null) {
+            const { getParser, safeParse } = require('./index');
+            const parser = getParser('java');
+            const rawTree = safeParse(parser, source);
+            if (translated === source) canonical = plainStructure(rawTree, source);
+            else if (rawTree && !rawTree.rootNode.hasError) {
+                const translatedTree = parseNameSource(parser, translated, safeParse);
+                canonical = literalOnlyTranslation(rawTree, translatedTree, source, translated);
+                if (!canonical) {
+                    const before = typeNameStructure(rawTree);
+                    if (before !== null) canonical = before === typeNameStructure(translatedTree);
+                }
+            }
+        }
+    }
+    canonicalSources.set(source, canonical);
+    return canonical;
+}
+
+// The member declarations a source's parse errors lie in, by line range
+// ([startLine, endLine] each), or null when an error is outside every member
+// (an import, a type header, a type body between members) or the source
+// needs lexical translation. Keyed by source text.
+const MEMBER_DECLARATIONS = new Set(['method_declaration', 'constructor_declaration',
+    'compact_constructor_declaration', 'field_declaration', 'constant_declaration', 'static_initializer',
+    'block', 'annotation_type_element_declaration']);
+const TYPE_BODIES = new Set(['class_body', 'interface_body', 'enum_body_declarations', 'annotation_type_body']);
+const errorScopeSources = new (require('../core/source-memo').BoundedMap)({ maxEntries: 256,
+    maxWeight: 8 * 1024 * 1024, weigh: (_scopes, source) => source.length * 2 });
+
+function errorMemberScopes(source) {
+    const saved = errorScopeSources.get(source);
+    if (saved !== undefined) return saved;
+    let scopes = null;
+    if (!source.includes('\\u') && !source.includes('\\{') && !noncanonicalIdentifier(source)) {
+        const tree = lazySourceMemoModule().parsedSource('java', source);
+        if (tree) {
+            scopes = [];
+            const stack = [tree.rootNode];
+            while (stack.length && scopes) {
+                const node = stack.pop();
+                if (node.type === 'ERROR' || node.isMissing) {
+                    let member = node.parent;
+                    while (member && !(MEMBER_DECLARATIONS.has(member.type) && TYPE_BODIES.has(member.parent?.type))) {
+                        member = member.type === 'ERROR' ? null : member.parent;
+                    }
+                    if (!member) scopes = null;
+                    else scopes.push([member.startPosition.row + 1, member.endPosition.row + 1]);
+                    continue;
+                }
+                if (!node.hasError) continue;
+                const children = node.children;
+                for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]);
+            }
+            if (scopes && !scopes.length && !plainStructure(tree, source)) scopes = null;
+        }
+    }
+    errorScopeSources.set(source, scopes);
+    return scopes;
+}
+
+const typeOwnerSources = new (require('../core/source-memo').SourceMemo)({
+    maxEntries: 128, maxWeight: 16 * 1024 * 1024,
+    weigh: facts => facts.weight,
+});
+
+function typeNameOwnersAt(source, site) {
+    if (typeof source !== 'string' || !Number.isInteger(site?.start) || !Number.isInteger(site?.line)) return null;
+    const key = `${site.start}:${site.line}`;
+    const facts = typeOwnerSources.get('java', source) || { sites: new Map(), weight: 0 };
+    const { sites } = facts;
+    if (sites.has(key)) return sites.get(key);
+    const owners = typeNameOwnersAtUncached(source, site);
+    const result = owners && Object.freeze(owners.map(owner => Object.freeze(owner)));
+    if (sites.size < 4096) {
+        sites.set(key, result);
+        facts.weight += key.length * 2 + 32 + (result?.length || 0) * 32;
+        typeOwnerSources.set('java', source, facts);
+    }
+    return result;
+}
+
+function typeNameOwnersAtUncached(source, site) {
+    if (!typeNameSourceCanonical(source) || !Number.isInteger(site?.start)) return null;
+    const tree = lazySourceMemoModule().parsedSource('java', source);
+    if (!tree) return null;
+    let node = tree.rootNode.descendantForIndex(site.start, site.start + 1);
+    if (!node || node.startPosition.row + 1 !== site.line) return null;
+    const owners = [];
+    for (; node; node = node.parent) {
+        // An anonymous body can inherit type names from its own base.
+        if (node.type === 'class_body' && ['object_creation_expression', 'enum_constant'].includes(node.parent?.type)) return null;
+        if (['class_declaration', 'interface_declaration', 'enum_declaration',
+            'record_declaration', 'annotation_type_declaration'].includes(node.type)) {
+            owners.push({ start: node.startIndex, end: node.endIndex });
+        }
+    }
+    return owners.length ? owners : null;
+}
+
+module.exports = { translateUnicodeEscapes, typeNameSourceCanonical, typeNameOwnersAt };