jsii-reflect 1.117.0 → 1.118.0

package/bin/jsii-query

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./jsii-query.js');

package/bin/jsii-query.d.ts

@@ -0,0 +1,2 @@
+import '@jsii/check-node/run';
+//# sourceMappingURL=jsii-query.d.ts.map

package/bin/jsii-query.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@jsii/check-node/run");
+const chalk = require("chalk");
+const yargs = require("yargs");
+const jsii_query_1 = require("../lib/jsii-query");
+async function main() {
+    const argv = await yargs
+        .usage('$0 <FILE> [QUERY...]', 'Queries a jsii file for its entries.', (args) => args
+        .positional('FILE', {
+        type: 'string',
+        desc: 'path to a .jsii file or directory to load',
+    })
+        .positional('QUERY', {
+        type: 'string',
+        desc: 'a query or filter expression to include or exclude items',
+    }))
+        .option('types', {
+        type: 'boolean',
+        alias: 't',
+        desc: 'after selecting API elements, show all selected types, as well as types containing selected members',
+        default: false,
+    })
+        .option('members', {
+        type: 'boolean',
+        alias: 'm',
+        desc: 'after selecting API elements, show all selected members, as well as members of selected types',
+        default: false,
+    })
+        .options('docs', {
+        type: 'boolean',
+        alias: 'd',
+        desc: 'show documentation for selected elements',
+        default: false,
+    })
+        .option('closure', {
+        type: 'boolean',
+        alias: 'c',
+        default: false,
+        desc: 'Load dependencies of package without assuming its a JSII package itself',
+    })
+        .strict().epilogue(`
+REMARKS
+-------
+
+There can be more than one QUERY part, which progressively filters from or adds
+to the list of selected elements.
+
+QUERY is of the format:
+
+    [<op>]<kind>[:<expression>]
+
+Where:
+
+    <op>          The type of operation to apply. Absent means '.'
+             +    Adds new API elements matching the selector to the selection.
+                  If this selects types, it also includes all type's members.
+             -    Removes API elements from the current selection that match
+                  the selector.
+             .    Removes API elements from the current selection that do NOT
+                  match the selector (i.e., retain only those that DO match
+                  the selector) (default)
+    <kind>        Type of API element to select. One of 'type' or 'member',
+                  or any of its more specific sub-types such as 'class',
+                  'interface', 'struct', 'enum', 'property', 'method', etc.
+                  Also supports aliases like 'c', 'm', 'mem', 's', 'p', etc.
+    <expression>  A JavaScript expression that will be evaluated against
+                  the member. Has access to a number of attributes like
+                  kind, ancestors, abstract, base, datatype, docs, interfaces,
+                  name, initializer, optional, overrides, protected, returns,
+                  parameters, static, variadic, type. The types are the
+                  same types as offered by the jsii-reflect class model.
+
+If the first expression of the query has operator '+', then the query starts
+empty and the selector determines the initial set. Otherwise the query starts
+with all elements and the first expression is a filter on it.
+
+This file evaluates the expressions as JavaScript, so this tool is not safe
+against untrusted input!
+
+Don't forget to mind your shell escaping rules when you write query expressions.
+
+Don't forget to add -- to terminate option parsing if you write negative expressions.
+
+EXAMPLES
+-------
+
+Select all enums:
+$ jsii-query --types node_modules/aws-cdk-lib enum
+
+Select all methods with "grant" in their name:
+$ jsii-query --members node_modules/aws-cdk-lib 'method:name.includes("grant")'
+
+Select all classes that have a grant method:
+$ jsii-query --types node_modules/aws-cdk-lib class 'method:name.includes("grant")'
+    -or-
+$ jsii-query --types -- node_modules/aws-cdk-lib -interface 'method:name.includes("grant")'
+                    ^^^^ note this
+
+Select all classes that have methods that are named either 'foo' or 'bar':
+$ jsii-query --types node_modules/some-package '+method:name=="foo"' '+method:name=="bar"' .class
+
+`).argv;
+    // Add some fields that we know are there but yargs typing doesn't know
+    const options = argv;
+    if (!(options.types || options.members)) {
+        throw new Error('At least --types or --members must be specified');
+    }
+    // Yargs is annoying; if the user uses '--' to terminate the option list,
+    // it will not parse positionals into `QUERY` but into `_`
+    const expressions = [...options.QUERY, ...options._]
+        .map(String)
+        .map(jsii_query_1.parseExpression);
+    const result = await (0, jsii_query_1.jsiiQuery)({
+        fileName: options.FILE,
+        expressions,
+        closure: options.closure,
+        returnTypes: options.types,
+        returnMembers: options.members,
+    });
+    for (const element of result) {
+        console.log((0, jsii_query_1.renderElement)(element));
+        if (options.docs) {
+            console.log(chalk.gray((0, jsii_query_1.renderDocs)(element)
+                .split('\n')
+                .map((line) => `    ${line}`)
+                .join('\n')));
+            console.log('');
+        }
+    }
+    process.exitCode = result.length > 0 ? 0 : 1;
+}
+main().catch((e) => {
+    console.log(e);
+    process.exit(1);
+});
+//# sourceMappingURL=jsii-query.js.map

package/lib/hierarchical-set.d.ts

@@ -0,0 +1,17 @@
+export type HierarchicalElement = string[];
+export declare class HierarchicalSet {
+    private root;
+    constructor(elements?: Iterable<HierarchicalElement>);
+    addAll(elements: Iterable<HierarchicalElement>): this;
+    add(element: HierarchicalElement): this;
+    /**
+     * Remove every element from LHS that doesn't have a prefix in RHS
+     */
+    intersect(rhs: HierarchicalSet): this;
+    remove(rhs: Iterable<HierarchicalElement>): this;
+    get size(): number;
+    [Symbol.iterator](): Iterator<HierarchicalElement, HierarchicalElement, any>;
+    has(el: HierarchicalElement): boolean;
+    private findNode;
+}
+//# sourceMappingURL=hierarchical-set.d.ts.map

package/lib/hierarchical-set.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HierarchicalSet = void 0;
+class HierarchicalSet {
+    constructor(elements) {
+        this.root = {
+            exists: false,
+            children: {},
+        };
+        if (elements) {
+            this.addAll(elements);
+        }
+    }
+    addAll(elements) {
+        for (const element of elements) {
+            this.add(element);
+        }
+        return this;
+    }
+    add(element) {
+        if (element.length === 0) {
+            throw new Error('Elements may not be empty');
+        }
+        let node = this.root;
+        for (const segment of element) {
+            if (!(segment in node.children)) {
+                node.children[segment] = {
+                    exists: false,
+                    children: {},
+                };
+            }
+            node = node.children[segment];
+        }
+        node.exists = true;
+        return this;
+    }
+    /**
+     * Remove every element from LHS that doesn't have a prefix in RHS
+     */
+    intersect(rhs) {
+        const retainSet = new HierarchicalSet();
+        for (const el of Array.from(this)) {
+            let found = false;
+            for (let i = 0; i < el.length && !found; i++) {
+                found = found || rhs.has(el.slice(0, i + 1));
+            }
+            if (found) {
+                retainSet.add(el);
+            }
+        }
+        this.root = retainSet.root;
+        return this;
+    }
+    remove(rhs) {
+        for (const el of rhs) {
+            const found = this.findNode(el);
+            if (found) {
+                const [parent, key] = found;
+                delete parent.children[key];
+            }
+        }
+        return this;
+    }
+    get size() {
+        return Array.from(this).length;
+    }
+    [Symbol.iterator]() {
+        if (Object.keys(this.root.children).length === 0) {
+            return {
+                next() {
+                    return { done: true };
+                },
+            };
+        }
+        const stack = [];
+        function cursorFrom(node) {
+            return {
+                trie: node.children,
+                keys: Object.keys(node.children),
+                index: 0,
+            };
+        }
+        stack.push(cursorFrom(this.root));
+        let done = false;
+        let cur = stack[stack.length - 1];
+        /**
+         * Move 'cur' to the next node in the trie
+         */
+        function advance() {
+            // If we can descend, let's
+            if (!isEmpty(cur.trie[cur.keys[cur.index]])) {
+                stack.push(cursorFrom(cur.trie[cur.keys[cur.index]]));
+                cur = stack[stack.length - 1];
+                return;
+            }
+            cur.index += 1;
+            while (cur.index >= cur.keys.length) {
+                stack.pop();
+                if (stack.length === 0) {
+                    done = true;
+                    break;
+                }
+                cur = stack[stack.length - 1];
+                // Advance the pointer after coming back.
+                cur.index += 1;
+            }
+        }
+        return {
+            next() {
+                while (!done && !cur.trie[cur.keys[cur.index]].exists) {
+                    advance();
+                }
+                const value = !done ? stack.map((f) => f.keys[f.index]) : undefined;
+                // Node's Array.from doesn't quite correctly implement the iterator protocol.
+                // If we return { value: <something>, done: true } it will pretend to never
+                // have seen <something>, so we need to split this into 2 steps.
+                // The TypeScript typings don't agree, so 'as any' that away.
+                const ret = (value ? { value, done } : { done });
+                if (!done) {
+                    advance();
+                }
+                return ret;
+            },
+        };
+    }
+    has(el) {
+        const found = this.findNode(el);
+        if (!found) {
+            return false;
+        }
+        const [node, last] = found;
+        return node.children?.[last]?.exists ?? false;
+    }
+    findNode(el) {
+        if (el.length === 0) {
+            throw new Error('Elements may not be empty');
+        }
+        const parts = [...el];
+        let parent = this.root;
+        while (parts.length > 1) {
+            const next = parts.splice(0, 1)[0];
+            parent = parent.children?.[next];
+            if (!parent) {
+                return undefined;
+            }
+        }
+        return [parent, parts[0]];
+    }
+}
+exports.HierarchicalSet = HierarchicalSet;
+function isEmpty(node) {
+    return Object.keys(node.children).length === 0;
+}
+//# sourceMappingURL=hierarchical-set.js.map

package/lib/jsii-query.d.ts

@@ -0,0 +1,41 @@
+import '@jsii/check-node/run';
+import { Documentable } from '../lib';
+export interface JsiiQueryOptions {
+    readonly fileName: string;
+    readonly expressions: QExpr[];
+    readonly closure?: boolean;
+    readonly returnTypes?: boolean;
+    readonly returnMembers?: boolean;
+}
+export declare function jsiiQuery(options: JsiiQueryOptions): Promise<ApiElement[]>;
+export declare class Predicate {
+    private readonly fn;
+    constructor(expr?: string);
+    apply(context: Record<string, unknown>): boolean;
+}
+type QExpr = QSelect | QFilter;
+/**
+ * Select adds elements
+ */
+interface QSelect {
+    readonly op: 'select';
+    readonly kind: ApiKind;
+    readonly expression?: string;
+}
+/**
+ * Filter retains elements
+ */
+interface QFilter {
+    readonly op: 'filter';
+    readonly remove: boolean;
+    readonly kind: ApiKind;
+    readonly expression?: string;
+}
+export declare function parseExpression(expr: string): QExpr;
+export declare function renderElement(el: ApiElement): string;
+export declare function renderDocs(el: ApiElement): string;
+declare const VALID_KINDS: readonly ["type", "interface", "class", "enum", "struct", "member", "property", "method", "initializer"];
+type ApiKind = (typeof VALID_KINDS)[number];
+type ApiElement = Documentable;
+export {};
+//# sourceMappingURL=jsii-query.d.ts.map

package/lib/jsii-query.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Predicate = void 0;
+exports.jsiiQuery = jsiiQuery;
+exports.parseExpression = parseExpression;
+exports.renderElement = renderElement;
+exports.renderDocs = renderDocs;
+/* eslint-disable @typescript-eslint/no-implied-eval */
+require("@jsii/check-node/run");
+const lib_1 = require("../lib");
+const hierarchical_set_1 = require("./hierarchical-set");
+const JSII_TREE_SUPPORTED_FEATURES = [
+    'intersection-types',
+    'class-covariant-overrides',
+];
+async function jsiiQuery(options) {
+    const typesys = new lib_1.TypeSystem();
+    if (options.closure) {
+        await typesys.loadNpmDependencies(options.fileName, {
+            validate: false,
+            supportedFeatures: JSII_TREE_SUPPORTED_FEATURES,
+        });
+    }
+    else {
+        await typesys.load(options.fileName, {
+            validate: false,
+            supportedFeatures: JSII_TREE_SUPPORTED_FEATURES,
+        });
+    }
+    const universe = selectAll(typesys);
+    const selectedElements = selectApiElements(universe, options.expressions);
+    expandSelectToParentsAndChildren(universe, selectedElements, options);
+    // The keys are sortable, so sort them, then get the original API elements back
+    // and return only those that were asked for.
+    // Then retain only the kinds we asked for, and sort them
+    return Array.from(selectedElements)
+        .sort()
+        .map((key) => universe.get(stringFromKey(key)))
+        .filter((x) => (isType(x) && options.returnTypes) ||
+        (isMember(x) && options.returnMembers));
+}
+// - if we are asking for types, include any type that's a parent of any of the selected members
+// - if we are asking for members, include all members that are a child of any of the selected types
+function expandSelectToParentsAndChildren(universe, selected, options) {
+    if (options.returnTypes) {
+        // All type keys from either type keys or member keys
+        selected.addAll(Array.from(selected).map(typeKey));
+    }
+    if (options.returnMembers) {
+        const allElements = new hierarchical_set_1.HierarchicalSet(Array.from(universe.keys()).map(keyFromString));
+        // Add all member keys that are members of a selected type
+        selected.addAll(new hierarchical_set_1.HierarchicalSet(allElements).intersect(selected));
+    }
+}
+function isType(x) {
+    return (x instanceof lib_1.ClassType ||
+        x instanceof lib_1.InterfaceType ||
+        x instanceof lib_1.EnumType);
+}
+function isMember(x) {
+    return x instanceof lib_1.Callable || x instanceof lib_1.Property;
+}
+/**
+ * Returns a unique key per API element, used because the jsii-reflect members don't guarantee uniqueness at the object level
+ *
+ * Keys have the property that parent keys are a prefix of child keys, and that the keys are in sort order
+ */
+function apiElementKey(x) {
+    if (isType(x)) {
+        return [`${x.fqn}`];
+    }
+    if (isMember(x)) {
+        const sort = x instanceof lib_1.Method && x.static
+            ? '000'
+            : x instanceof lib_1.Initializer
+                ? '001'
+                : '002';
+        return [`${x.parentType.fqn}`, `${sort}${x.name}`];
+    }
+    throw new Error('huh');
+}
+function stringFromKey(x) {
+    return x.map((s) => `${s}#`).join('');
+}
+function keyFromString(x) {
+    return x.split('#').slice(0, -1);
+}
+/**
+ * Given a type or member key, return the type key
+ */
+function typeKey(x) {
+    return [x[0]];
+}
+function selectApiElements(universe, expressions) {
+    const allKeys = new hierarchical_set_1.HierarchicalSet(Array.from(universe.keys()).map(keyFromString));
+    const currentSelection = expressions.length === 0 || expressions[0].op === 'filter'
+        ? new hierarchical_set_1.HierarchicalSet(allKeys)
+        : new hierarchical_set_1.HierarchicalSet();
+    for (const expr of expressions) {
+        const thisQuery = Array.from(filterElements(universe, allKeys, expr.kind, expr.expression));
+        if (expr.op === 'filter' && expr.remove) {
+            currentSelection.remove(thisQuery);
+        }
+        else if (expr.op === 'filter') {
+            currentSelection.intersect(new hierarchical_set_1.HierarchicalSet(thisQuery));
+        }
+        else {
+            currentSelection.addAll(thisQuery);
+        }
+    }
+    return currentSelection;
+}
+function* filterElements(universe, elements, kind, expression) {
+    const pred = new Predicate(expression);
+    for (const key of elements) {
+        const el = universe.get(stringFromKey(key));
+        if (!el) {
+            throw new Error(`Key not in universe: ${stringFromKey(key)}`);
+        }
+        if (matches(el, kind, pred)) {
+            yield key;
+        }
+    }
+}
+class Predicate {
+    constructor(expr) {
+        if (!expr) {
+            this.fn = () => true;
+        }
+        else {
+            const args = API_ELEMENT_ATTRIBUTES.join(',');
+            const body = `return Boolean(${expr});`;
+            try {
+                this.fn = Function(args, body);
+            }
+            catch (e) {
+                throw new Error(`Syntax error in selector: ${body}: ${e}`);
+            }
+        }
+    }
+    apply(context) {
+        return this.fn(...API_ELEMENT_ATTRIBUTES.map((attr) => context[attr]));
+    }
+}
+exports.Predicate = Predicate;
+/**
+ * Whether a given API element matches the filter
+ */
+function matches(el, kind, pred) {
+    const context = {};
+    if (el instanceof lib_1.ClassType) {
+        if (!['type', 'class'].includes(kind))
+            return false;
+        context.kind = 'class';
+    }
+    if (el instanceof lib_1.InterfaceType) {
+        const moreSpecificInterfaceType = el.datatype ? 'struct' : 'interface';
+        if (!['type', moreSpecificInterfaceType].includes(kind))
+            return false;
+        context.kind = moreSpecificInterfaceType;
+    }
+    if (el instanceof lib_1.EnumType) {
+        if (!['type', 'enum'].includes(kind))
+            return false;
+        context.kind = 'enum';
+    }
+    if (el instanceof lib_1.Property) {
+        if (!['member', 'property'].includes(kind))
+            return false;
+        context.kind = 'property';
+    }
+    if (el instanceof lib_1.Callable) {
+        const moreSpecificCallable = el instanceof lib_1.Initializer ? 'initializer' : 'method';
+        if (!['member', moreSpecificCallable].includes(kind))
+            return false;
+        context.kind = moreSpecificCallable;
+    }
+    Object.assign(context, Object.fromEntries(API_ELEMENT_ATTRIBUTES.map((attr) => [attr, el[attr]])));
+    const ret = pred.apply(context);
+    return ret;
+}
+function selectAll(typesys) {
+    return new Map([
+        ...typesys.classes,
+        ...typesys.interfaces,
+        ...typesys.enums,
+        ...typesys.methods,
+        ...typesys.properties,
+    ].map((el) => [stringFromKey(apiElementKey(el)), el]));
+}
+const KIND_ALIASES = {
+    t: 'type',
+    c: 'class',
+    i: 'interface',
+    s: 'struct',
+    e: 'enum',
+    p: 'property',
+    prop: 'property',
+    mem: 'member',
+    m: 'method',
+    init: 'initializer',
+    ctr: 'initializer',
+    constructor: 'initializer',
+};
+function parseExpression(expr) {
+    let op;
+    if (expr[0].match(/[a-z]/i)) {
+        op = '.';
+    }
+    else {
+        op = expr[0];
+        expr = expr.slice(1);
+    }
+    if (!['-', '+', '.'].includes(op)) {
+        throw new Error(`Invalid operator: ${op} (must be +, - or .)`);
+    }
+    const operator = op;
+    const [kind_, ...expressionParts] = expr.split(':');
+    const kind = (KIND_ALIASES[kind_] ??
+        kind_);
+    if (!VALID_KINDS.includes(kind)) {
+        throw new Error(`Invalid kind: ${kind} (must be one of ${VALID_KINDS.join(', ')})`);
+    }
+    return {
+        op: operator === '+' ? 'select' : 'filter',
+        remove: operator === '-',
+        kind,
+        expression: expressionParts?.join(':'),
+    };
+}
+function renderElement(el) {
+    if (el instanceof lib_1.ClassType) {
+        return combine(el.abstract ? 'abstract' : '', 'class', el.fqn);
+    }
+    if (el instanceof lib_1.InterfaceType) {
+        if (el.spec.datatype) {
+            return combine('struct', el.fqn);
+        }
+        return combine('interface', el.fqn);
+    }
+    if (el instanceof lib_1.EnumType) {
+        return combine('enum', el.fqn);
+    }
+    if (el instanceof lib_1.Property) {
+        const opt = el.optional ? '?' : '';
+        return combine(el.static ? 'static' : '', el.immutable ? 'readonly' : '', `${el.parentType.fqn}#${el.name}${opt}: ${el.type.toString()}`);
+    }
+    if (el instanceof lib_1.Method) {
+        return combine(el.static ? 'static' : '', `${el.parentType.fqn}#${el.name}(${renderParams(el.parameters)}): ${el.returns.toString()}`);
+    }
+    if (el instanceof lib_1.Initializer) {
+        return `${el.parentType.fqn}(${renderParams(el.parameters)}`;
+    }
+    return '???';
+}
+function renderDocs(el) {
+    return el.docs.toString();
+}
+function renderParams(ps) {
+    return (ps ?? [])
+        .map((p) => {
+        const opt = p.optional ? '?' : '';
+        const varia = p.variadic ? '...' : '';
+        const arr = p.variadic ? '[]' : '';
+        return `${varia}${p.name}${opt}: ${p.type.toString()}${arr}`;
+    })
+        .join(', ');
+}
+function combine(...xs) {
+    return xs.filter((x) => x).join(' ');
+}
+// A list of all valid API element kinds
+const VALID_KINDS = [
+    // Types
+    'type',
+    'interface',
+    'class',
+    'enum',
+    'struct',
+    // Members
+    'member',
+    'property',
+    'method',
+    'initializer',
+];
+const API_ELEMENT_ATTRIBUTES = [
+    'kind',
+    // Types
+    'ancestors',
+    'abstract',
+    'base',
+    'datatype',
+    'docs',
+    'interfaces',
+    'name',
+    // Members
+    'initializer',
+    'optional',
+    'overrides',
+    'protected',
+    'returns',
+    'parameters',
+    'static',
+    'variadic',
+    'type',
+];
+//# sourceMappingURL=jsii-query.js.map

package/lib/method.d.ts

@@ -39,5 +39,9 @@ export declare class Method extends Callable implements Documentable, Overridabl
      * Indicates if this is a static method.
      */
     get static(): boolean;
+    /**
+     * The Method that this method overrides, if any
+     */
+    get overriddenMethod(): Method | undefined;
 }
 //# sourceMappingURL=method.d.ts.map

package/lib/method.js

@@ -61,6 +61,16 @@ class Method extends callable_1.Callable {
     get static() {
         return !!this.spec.static;
     }
+    /**
+     * The Method that this method overrides, if any
+     */
+    get overriddenMethod() {
+        const o = this.overrides;
+        if (o && (o.isClassType() || o.isInterfaceType())) {
+            return o.ownMethods.find((m) => m.name === this.name);
+        }
+        return undefined;
+    }
 }
 exports.Method = Method;
 __decorate([

package/lib/property.d.ts

@@ -51,5 +51,9 @@ export declare class Property extends OptionalValue implements Documentable, Ove
      * Return the location in the repository
      */
     get locationInRepository(): SourceLocation | undefined;
+    /**
+     * The Property that this property overrides, if any
+     */
+    get overriddenProperty(): Property | undefined;
 }
 //# sourceMappingURL=property.d.ts.map

package/lib/property.js

@@ -76,6 +76,16 @@ class Property extends optional_value_1.OptionalValue {
     get locationInRepository() {
         return (0, source_1.locationInRepository)(this);
     }
+    /**
+     * The Property that this property overrides, if any
+     */
+    get overriddenProperty() {
+        const o = this.overrides;
+        if (o && (o.isClassType() || o.isInterfaceType())) {
+            return o.ownProperties.find((p) => p.name === this.name);
+        }
+        return undefined;
+    }
 }
 exports.Property = Property;
 //# sourceMappingURL=property.js.map

package/lib/type-system.d.ts

@@ -44,6 +44,7 @@ export declare class TypeSystem {
      */
     loadNpmDependencies(packageRoot: string, options?: {
         validate?: boolean;
+        supportedFeatures?: JsiiFeature[];
     }): Promise<void>;
     /**
      * Loads a jsii module or a single .jsii file into the type system.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsii-reflect",
-  "version": "1.117.0",
+  "version": "1.118.0",
   "description": "strongly-typed reflection library and tools for jsii",
   "license": "Apache-2.0",
   "author": {
@@ -34,19 +34,19 @@
     "package": "package-js"
   },
   "dependencies": {
-    "@jsii/check-node": "1.117.0",
-    "@jsii/spec": "1.117.0",
+    "@jsii/check-node": "1.118.0",
+    "@jsii/spec": "1.118.0",
     "chalk": "^4",
     "fs-extra": "^10.1.0",
-    "oo-ascii-tree": "^1.117.0",
+    "oo-ascii-tree": "^1.118.0",
     "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "@scope/jsii-calc-lib": "^1.117.0",
+    "@scope/jsii-calc-lib": "^1.118.0",
     "@types/fs-extra": "^9.0.13",
     "@types/yargs": "^17.0.33",
     "jsii": "^5.9.10",
-    "jsii-build-tools": "^1.117.0",
+    "jsii-build-tools": "^1.118.0",
     "jsii-calc": "^3.20.120"
   }
 }

package/test/__snapshots__/jsii-tree.test.js.snap

@@ -211,14 +211,28 @@ exports[`jsii-tree --all 1`] = `
  │ │ │ │     ├─┬ class SubSubclass (stable)
  │ │ │ │     │ ├── base: Subclass
  │ │ │ │     │ └─┬ members
- │ │ │ │     │   └── <initializer>() initializer (stable)
+ │ │ │ │     │   ├── <initializer>() initializer (stable)
+ │ │ │ │     │   ├─┬ sayHello() method (stable)
+ │ │ │ │     │   │ └── returns: string
+ │ │ │ │     │   ├─┬ name property (stable)
+ │ │ │ │     │   │ └── type: string
+ │ │ │ │     │   └─┬ unique property (stable)
+ │ │ │ │     │     └── type: string
  │ │ │ │     ├─┬ class Subclass (stable)
  │ │ │ │     │ ├── base: Superclass
  │ │ │ │     │ └─┬ members
- │ │ │ │     │   └── <initializer>() initializer (stable)
+ │ │ │ │     │   ├── <initializer>() initializer (stable)
+ │ │ │ │     │   ├─┬ sayHello() method (stable)
+ │ │ │ │     │   │ └── returns: string
+ │ │ │ │     │   └─┬ name property (stable)
+ │ │ │ │     │     └── type: string
  │ │ │ │     ├─┬ class Superclass (stable)
  │ │ │ │     │ └─┬ members
- │ │ │ │     │   └── <initializer>() initializer (stable)
+ │ │ │ │     │   ├── <initializer>() initializer (stable)
+ │ │ │ │     │   ├─┬ sayHello() method (stable)
+ │ │ │ │     │   │ └── returns: string
+ │ │ │ │     │   └─┬ name property (stable)
+ │ │ │ │     │     └── type: string
  │ │ │ │     └─┬ interface IBase (stable)
  │ │ │ │       └─┬ members
  │ │ │ │         └─┬ something property (stable)
@@ -4510,13 +4524,20 @@ exports[`jsii-tree --members 1`] = `
  │ │ │ │     │   └── addUnrelatedMember property
  │ │ │ │     ├─┬ class SubSubclass
  │ │ │ │     │ └─┬ members
- │ │ │ │     │   └── <initializer>() initializer
+ │ │ │ │     │   ├── <initializer>() initializer
+ │ │ │ │     │   ├── sayHello() method
+ │ │ │ │     │   ├── name property
+ │ │ │ │     │   └── unique property
  │ │ │ │     ├─┬ class Subclass
  │ │ │ │     │ └─┬ members
- │ │ │ │     │   └── <initializer>() initializer
+ │ │ │ │     │   ├── <initializer>() initializer
+ │ │ │ │     │   ├── sayHello() method
+ │ │ │ │     │   └── name property
  │ │ │ │     ├─┬ class Superclass
  │ │ │ │     │ └─┬ members
- │ │ │ │     │   └── <initializer>() initializer
+ │ │ │ │     │   ├── <initializer>() initializer
+ │ │ │ │     │   ├── sayHello() method
+ │ │ │ │     │   └── name property
  │ │ │ │     └─┬ interface IBase
  │ │ │ │       └─┬ members
  │ │ │ │         └── something property

package/test/__snapshots__/tree.test.js.snap

@@ -406,14 +406,28 @@ exports[`showAll 1`] = `
  │ │ │ │     ├─┬ class SubSubclass
  │ │ │ │     │ ├── base: Subclass
  │ │ │ │     │ └─┬ members
- │ │ │ │     │   └── <initializer>() initializer
+ │ │ │ │     │   ├── <initializer>() initializer
+ │ │ │ │     │   ├─┬ sayHello() method
+ │ │ │ │     │   │ └── returns: string
+ │ │ │ │     │   ├─┬ name property
+ │ │ │ │     │   │ └── type: string
+ │ │ │ │     │   └─┬ unique property
+ │ │ │ │     │     └── type: string
  │ │ │ │     ├─┬ class Subclass
  │ │ │ │     │ ├── base: Superclass
  │ │ │ │     │ └─┬ members
- │ │ │ │     │   └── <initializer>() initializer
+ │ │ │ │     │   ├── <initializer>() initializer
+ │ │ │ │     │   ├─┬ sayHello() method
+ │ │ │ │     │   │ └── returns: string
+ │ │ │ │     │   └─┬ name property
+ │ │ │ │     │     └── type: string
  │ │ │ │     ├─┬ class Superclass
  │ │ │ │     │ └─┬ members
- │ │ │ │     │   └── <initializer>() initializer
+ │ │ │ │     │   ├── <initializer>() initializer
+ │ │ │ │     │   ├─┬ sayHello() method
+ │ │ │ │     │   │ └── returns: string
+ │ │ │ │     │   └─┬ name property
+ │ │ │ │     │     └── type: string
  │ │ │ │     └─┬ interface IBase
  │ │ │ │       └─┬ members
  │ │ │ │         └─┬ something property

package/test/hierarchical-set.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hierarchical-set.test.d.ts.map

package/test/hierarchical-set.test.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hierarchical_set_1 = require("../lib/hierarchical-set");
+test('empty set', () => {
+    expect(Array.from(new hierarchical_set_1.HierarchicalSet())).toEqual([]);
+});
+test('set iteration', () => {
+    const hs = new hierarchical_set_1.HierarchicalSet([
+        ['a'],
+        ['a', 'b', 'c'],
+        ['a', 'b', 'd'],
+        ['a', 'e'],
+        ['f'],
+    ]);
+    expect(Array.from(hs)).toEqual([
+        ['a'],
+        ['a', 'b', 'c'],
+        ['a', 'b', 'd'],
+        ['a', 'e'],
+        ['f'],
+    ]);
+});
+test('add prefix after child', () => {
+    const hs = new hierarchical_set_1.HierarchicalSet();
+    hs.addAll([['a', 'b']]);
+    hs.addAll([['a']]);
+    expect(Array.from(hs)).toEqual([['a'], ['a', 'b']]);
+});
+describe('remove', () => {
+    test('remove literals', () => {
+        const x = new hierarchical_set_1.HierarchicalSet([['a', 'b'], ['c'], ['d']]);
+        x.remove([['a', 'b'], ['c']]);
+        expect(Array.from(x)).toEqual([['d']]);
+    });
+    test('remove parents', () => {
+        const x = new hierarchical_set_1.HierarchicalSet([['a', 'b'], ['c'], ['d']]);
+        x.remove([['a']]);
+        expect(Array.from(x)).toEqual([['c'], ['d']]);
+    });
+});
+describe('intersect', () => {
+    test('retains literal elements', () => {
+        const x = new hierarchical_set_1.HierarchicalSet([['a', 'b'], ['c'], ['d']]);
+        x.intersect(new hierarchical_set_1.HierarchicalSet([['a', 'b'], ['c']]));
+        expect(Array.from(x)).toEqual([['a', 'b'], ['c']]);
+    });
+    test('retains children of parents', () => {
+        const x = new hierarchical_set_1.HierarchicalSet([['a', 'b'], ['c'], ['d']]);
+        x.intersect(new hierarchical_set_1.HierarchicalSet([['a']]));
+        expect(Array.from(x)).toEqual([['a', 'b']]);
+    });
+    test('parent and child only retains child', () => {
+        const x = new hierarchical_set_1.HierarchicalSet([['a'], ['a', 'b']]);
+        x.intersect(new hierarchical_set_1.HierarchicalSet([['a', 'b'], ['c']]));
+        expect(Array.from(x)).toEqual([['a', 'b']]);
+    });
+});
+//# sourceMappingURL=hierarchical-set.test.js.map

package/test/jsii-query.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jsii-query.test.d.ts.map

package/test/jsii-query.test.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const jsii_query_1 = require("../lib/jsii-query");
+describe('parseExpression', () => {
+    test('+', () => {
+        expect((0, jsii_query_1.parseExpression)('+type')).toMatchObject({
+            op: 'select',
+            kind: 'type',
+        });
+    });
+    test('-', () => {
+        expect((0, jsii_query_1.parseExpression)('-type')).toMatchObject({
+            op: 'filter',
+            kind: 'type',
+            remove: true,
+        });
+    });
+    test('.', () => {
+        expect((0, jsii_query_1.parseExpression)('.type')).toMatchObject({
+            op: 'filter',
+            kind: 'type',
+            remove: false,
+        });
+        expect((0, jsii_query_1.parseExpression)('type')).toMatchObject({
+            op: 'filter',
+            kind: 'type',
+            remove: false,
+        });
+    });
+    test('with expression', () => {
+        expect((0, jsii_query_1.parseExpression)('.property:name.startsWith("x")')).toMatchObject({
+            op: 'filter',
+            kind: 'property',
+            remove: false,
+            expression: 'name.startsWith("x")',
+        });
+    });
+});
+describe('Predicate', () => {
+    test('Simple', () => {
+        const p = new jsii_query_1.Predicate('name.startsWith("ba")');
+        expect(p.apply({ name: 'banana' })).toBeTruthy();
+        expect(p.apply({ name: 'blob' })).toBeFalsy();
+    });
+    test('empty', () => {
+        const p = new jsii_query_1.Predicate();
+        expect(p.apply({ name: 'banana' })).toBeTruthy();
+        expect(p.apply({ name: 'blob' })).toBeTruthy();
+    });
+});
+describe('filtering', () => {
+    test('empty filter returns everything', async () => {
+        const result = await query([], 'members');
+        expect(result.length).toBeGreaterThan(700);
+        expect(result).toContainEqual('readonly jsii-calc.ExportedBaseClass#success: boolean');
+    });
+    test('filter on method name', async () => {
+        const result = await query([(0, jsii_query_1.parseExpression)('method:name.includes("con")')], 'members');
+        expect(result).toContainEqual('static @scope/jsii-calc-base-of-base.StaticConsumer#consume(..._args: any[]): void');
+    });
+    test('filter on methods but expect types', async () => {
+        const result = await query([(0, jsii_query_1.parseExpression)('method:name.includes("con")')], 'types');
+        expect(result).toContainEqual('class @scope/jsii-calc-base-of-base.StaticConsumer');
+    });
+    test('filter on type but expect members', async () => {
+        const result = await query([(0, jsii_query_1.parseExpression)('class:name == "StaticConsumer"')], 'members');
+        expect(result).toContainEqual('static @scope/jsii-calc-base-of-base.StaticConsumer#consume(..._args: any[]): void');
+    });
+    test('filter on classes with a separate expression', async () => {
+        const result = await query([
+            (0, jsii_query_1.parseExpression)('method:name.includes("con")'),
+            (0, jsii_query_1.parseExpression)('class'),
+        ], 'members');
+        expect(result).toContainEqual('static @scope/jsii-calc-base-of-base.StaticConsumer#consume(..._args: any[]): void');
+    });
+});
+async function query(exp, what = 'all') {
+    const jsiiCalcDir = path.dirname(require.resolve('jsii-calc/package.json'));
+    const result = await (0, jsii_query_1.jsiiQuery)({
+        fileName: jsiiCalcDir,
+        expressions: exp,
+        returnMembers: what !== 'types',
+        returnTypes: what !== 'members',
+    });
+    return result.map(jsii_query_1.renderElement);
+}
+//# sourceMappingURL=jsii-query.test.js.map

package/test/type-system.test.js

@@ -180,6 +180,8 @@ test('overridden member knows about both parent types', () => {
     expect(booMethod.parentType).toBe(subType);
     expect(booMethod.definingType).toBe(subType);
     expect(booMethod.overrides).toBe(superType);
+    const superBooMethod = superType.allMethods.find((m) => m.name === 'boo');
+    expect(booMethod.overriddenMethod).toEqual(superBooMethod);
 });
 describe('Stability', () => {
     test('can be read on an item', () => {