add names anon molql functions for debugging/profiling

src/mol-model/structure/query/queries/generators.ts

@@ -58,7 +58,7 @@ export function atoms(params?: Partial<AtomsQueryParams>): StructureQuery {
 }
 
 function atomGroupsLinear(atomTest: QueryPredicate): StructureQuery {
-    return ctx => {
+    return function query_atomGroupsLinear(ctx) {
         const { inputStructure } = ctx;
         const { units } = inputStructure;
         const l = ctx.pushCurrentElement();
@@ -83,7 +83,7 @@ function atomGroupsLinear(atomTest: QueryPredicate): StructureQuery {
 }
 
 function atomGroupsSegmented({ unitTest, entityTest, chainTest, residueTest, atomTest }: AtomsQueryParams): StructureQuery {
-    return ctx => {
+    return function query_atomGroupsSegmented(ctx) {
         const { inputStructure } = ctx;
         const { units } = inputStructure;
         const l = ctx.pushCurrentElement();
@@ -152,7 +152,7 @@ function atomGroupsSegmented({ unitTest, entityTest, chainTest, residueTest, ato
 }
 
 function atomGroupsGrouped({ unitTest, entityTest, chainTest, residueTest, atomTest, groupBy }: AtomsQueryParams): StructureQuery {
-    return ctx => {
+    return function query_atomGroupsGrouped(ctx) {
         const { inputStructure } = ctx;
         const { units } = inputStructure;
         const l = ctx.pushCurrentElement();
@@ -224,7 +224,7 @@ function getRingStructure(unit: Unit.Atomic, ring: UnitRing, inputStructure: Str
 }
 
 export function rings(fingerprints?: ArrayLike<UnitRing.Fingerprint>): StructureQuery {
-    return ctx => {
+    return function query_rings(ctx) {
         const { units } = ctx.inputStructure;
         let ret = StructureSelection.LinearBuilder(ctx.inputStructure);
 
@@ -258,7 +258,7 @@ export function rings(fingerprints?: ArrayLike<UnitRing.Fingerprint>): Structure
 }
 
 export function querySelection(selection: StructureQuery, query: StructureQuery, inComplement: boolean = false): StructureQuery {
-    return ctx => {
+    return function query_querySelection(ctx) {
         const targetSel = selection(ctx);
         if (StructureSelection.structureCount(targetSel) === 0) return targetSel;
 

src/mol-model/structure/query/queries/internal.ts

@@ -20,7 +20,7 @@ export function defaultLinkTest(ctx: QueryContext) {
 }
 
 export function atomicSequence(): StructureQuery {
-    return ctx => {
+    return function query_atomicSequence(ctx) {
         const { inputStructure } = ctx;
         const l = StructureElement.Location.create();
 
@@ -48,7 +48,7 @@ export function atomicSequence(): StructureQuery {
 }
 
 export function water(): StructureQuery {
-    return ctx => {
+    return function query_water(ctx) {
         const { inputStructure } = ctx;
         const l = StructureElement.Location.create();
 
@@ -67,7 +67,7 @@ export function water(): StructureQuery {
 }
 
 export function atomicHet(): StructureQuery {
-    return ctx => {
+    return function query_atomicHet(ctx) {
         const { inputStructure } = ctx;
         const l = StructureElement.Location.create();
 
@@ -97,7 +97,7 @@ export function atomicHet(): StructureQuery {
 }
 
 export function spheres(): StructureQuery {
-    return ctx => {
+    return function query_spheres(ctx) {
         const { inputStructure } = ctx;
 
         const units: Unit[] = [];
@@ -118,7 +118,7 @@ export function bundleElementImpl(groupedUnits: number[][], ranges: number[], se
 }
 
 export function bundleGenerator(elements: BundleElement[]): StructureQuery {
-    return ctx => {
+    return function query_bundleGenerator(ctx) {
         const bundle: Bundle = {
             hash: ctx.inputStructure.hashCode,
             elements

src/mol-model/structure/query/queries/modifiers.ts

@@ -45,7 +45,7 @@ function getWholeResidues(ctx: QueryContext, source: Structure, structure: Struc
 }
 
 export function wholeResidues(query: StructureQuery): StructureQuery {
-    return ctx => {
+    return function query_wholeResidues(ctx) {
         const inner = query(ctx);
         if (StructureSelection.isSingleton(inner)) {
             return StructureSelection.Singletons(ctx.inputStructure, getWholeResidues(ctx, ctx.inputStructure, inner.structure));
@@ -141,7 +141,7 @@ function findStructureRadius(ctx: QueryContext, eRadius: QueryFn<number>) {
 }
 
 export function includeSurroundings(query: StructureQuery, params: IncludeSurroundingsParams): StructureQuery {
-    return ctx => {
+    return function query_includeSurroundings(ctx) {
         const inner = query(ctx);
 
         if (params.elementRadius) {
@@ -180,7 +180,7 @@ export function includeSurroundings(query: StructureQuery, params: IncludeSurrou
 }
 
 export function querySelection(selection: StructureQuery, query: StructureQuery): StructureQuery {
-    return ctx => {
+    return function query_querySelection(ctx) {
         const targetSel = selection(ctx);
         if (StructureSelection.structureCount(targetSel) === 0) return targetSel;
 
@@ -198,7 +198,7 @@ export function querySelection(selection: StructureQuery, query: StructureQuery)
 }
 
 export function intersectBy(query: StructureQuery, by: StructureQuery): StructureQuery {
-    return ctx => {
+    return function query_intersectBy(ctx) {
         const selection = query(ctx);
         if (StructureSelection.structureCount(selection) === 0) return selection;
 
@@ -218,7 +218,7 @@ export function intersectBy(query: StructureQuery, by: StructureQuery): Structur
 }
 
 export function exceptBy(query: StructureQuery, by: StructureQuery): StructureQuery {
-    return ctx => {
+    return function query_exceptBy(ctx) {
         const selection = query(ctx);
         if (StructureSelection.structureCount(selection) === 0) return selection;
 
@@ -238,7 +238,7 @@ export function exceptBy(query: StructureQuery, by: StructureQuery): StructureQu
 }
 
 export function union(query: StructureQuery): StructureQuery {
-    return ctx => {
+    return function query_union(ctx) {
         const ret = StructureSelection.LinearBuilder(ctx.inputStructure);
         ret.add(StructureSelection.unionStructure(query(ctx)));
         return ret.getSelection();
@@ -246,7 +246,7 @@ export function union(query: StructureQuery): StructureQuery {
 }
 
 export function expandProperty(query: StructureQuery, property: QueryFn): StructureQuery {
-    return ctx => {
+    return function query_expandProperty(ctx) {
         const src = query(ctx);
         const propertyToStructureIndexMap = new Map<any, UniqueArray<number>>();
 
@@ -307,7 +307,7 @@ export interface IncludeConnectedParams {
 export function includeConnected({ query, layerCount, wholeResidues, linkTest }: IncludeConnectedParams): StructureQuery {
     const bt = linkTest || defaultLinkTest;
     const lc = Math.max(layerCount, 0);
-    return ctx => {
+    return function query_includeConnected(ctx) {
         const builder = StructureSelection.UniqueBuilder(ctx.inputStructure);
         const src = query(ctx);
         ctx.pushCurrentLink();

src/mol-script/runtime/query/compiler.ts

@@ -61,7 +61,7 @@ export namespace QueryCompiledSymbol {
 
 export namespace CompiledQueryFn {
     export function Const(value: any): CompiledQueryFn  {
-        return { isConst: true, fn: ctx => value };
+        return { isConst: true, fn: function CompiledQueryFn_Const(ctx) { return value } };
     }
 
     export function Dynamic(fn: QueryFn): CompiledQueryFn {
@@ -140,7 +140,7 @@ class SymbolRuntimeImpl<S extends MSymbol> implements QuerySymbolRuntime {
 }
 
 function createDynamicFn<S extends MSymbol>(fn: QuerySymbolFn<S>, args: any): QueryFn {
-    return ctx => fn(ctx, args);
+    return function DynamicFn(ctx) { return fn(ctx, args) };
 }
 
 function _compile(ctx: QueryCompilerCtx, expression: Expression): CompiledQueryFn {

src/mol-script/runtime/query/table.ts

@@ -20,14 +20,14 @@ import { bundleElementImpl, bundleGenerator } from '../../../mol-model/structure
 const symbols = [
     // ============= TYPES =============
 
-    C(MolScript.core.type.bool, (ctx, v) => !!v[0](ctx)),
-    C(MolScript.core.type.num, (ctx, v) => +v[0](ctx)),
-    C(MolScript.core.type.str, (ctx, v) => '' + v[0](ctx)),
-    C(MolScript.core.type.list, (ctx, xs) => QueryRuntimeArguments.forEachEval(xs, ctx, (v, i, list) => list[i] = v, [] as any[])),
-    C(MolScript.core.type.set, (ctx, xs) => QueryRuntimeArguments.forEachEval(xs, ctx, (v, i, set) => set.add(v), new Set<any>())),
-    C(MolScript.core.type.regex, (ctx, v) => new RegExp(v[0](ctx), (v[1] && v[1](ctx)) || '')),
-    C(MolScript.core.type.bitflags, (ctx, v) => +v[0](ctx)),
-    C(MolScript.core.type.compositeKey, (ctx, xs) => QueryRuntimeArguments.forEachEval(xs, ctx, (v, i, list) => list[i] = '' + v, [] as string[]).join('-')),
+    C(MolScript.core.type.bool, function core_type_bool(ctx, v) { return !!v[0](ctx) }),
+    C(MolScript.core.type.num, function core_type_num(ctx, v) { return +v[0](ctx) }),
+    C(MolScript.core.type.str, function core_type_str(ctx, v) { return '' + v[0](ctx) }),
+    C(MolScript.core.type.list, function core_type_list(ctx, xs) { return QueryRuntimeArguments.forEachEval(xs, ctx, (v, i, list) => list[i] = v, [] as any[]) }),
+    C(MolScript.core.type.set, function core_type_set(ctx, xs) { return QueryRuntimeArguments.forEachEval(xs, ctx, function core_type_set_argEval(v, i, set) { return set.add(v) }, new Set<any>()) }),
+    C(MolScript.core.type.regex, function core_type_regex(ctx, v) { return new RegExp(v[0](ctx), (v[1] && v[1](ctx)) || '') }),
+    C(MolScript.core.type.bitflags, function core_type_bitflags(ctx, v) { return +v[0](ctx) }),
+    C(MolScript.core.type.compositeKey, function core_type_compositeKey(ctx, xs) { return QueryRuntimeArguments.forEachEval(xs, ctx, (v, i, list) => list[i] = '' + v, [] as string[]).join('-') }),
 
     // ============= LOGIC ================
     C(MolScript.core.logic.not, (ctx, v) => !v[0](ctx)),
@@ -152,8 +152,8 @@ const symbols = [
     C(MolScript.core.list.getAt, (ctx, v) => v[0](ctx)[v[1](ctx)]),
 
     // ============= SET ================
-    C(MolScript.core.set.has, (ctx, v) => v[0](ctx).has(v[1](ctx))),
-    C(MolScript.core.set.isSubset, (ctx, v) => SetUtils.isSuperset(v[1](ctx) as Set<any>, v[0](ctx) as Set<any>)),
+    C(MolScript.core.set.has, function core_set_has(ctx, v) { return v[0](ctx).has(v[1](ctx)) }),
+    C(MolScript.core.set.isSubset, function core_set_isSubset(ctx, v) { return SetUtils.isSuperset(v[1](ctx) as Set<any>, v[0](ctx) as Set<any>) }),
 
     // ============= FLAGS ================
     C(MolScript.core.flags.hasAny, (ctx, v) => {
@@ -219,34 +219,34 @@ const symbols = [
     })(ctx)),
 
     // ============= GENERATORS ================
-    D(MolScript.structureQuery.generator.atomGroups, (ctx, xs) => Queries.generators.atoms({
+    D(MolScript.structureQuery.generator.atomGroups, function structureQuery_generator_atomGroups(ctx, xs) { return Queries.generators.atoms({
         entityTest: xs['entity-test'],
         chainTest: xs['chain-test'],
         residueTest: xs['residue-test'],
         atomTest: xs['atom-test'],
         groupBy: xs['group-by']
-    })(ctx)),
+    })(ctx) }),
 
-    D(MolScript.structureQuery.generator.all, (ctx) => Queries.generators.all(ctx)),
-    D(MolScript.structureQuery.generator.empty, (ctx) => Queries.generators.none(ctx)),
+    D(MolScript.structureQuery.generator.all, function structureQuery_generator_all(ctx) { return Queries.generators.all(ctx) }),
+    D(MolScript.structureQuery.generator.empty, function structureQuery_generator_empty(ctx) { return Queries.generators.none(ctx) }),
 
     // ============= MODIFIERS ================
 
-    D(MolScript.structureQuery.modifier.includeSurroundings, (ctx, xs) => Queries.modifiers.includeSurroundings(xs[0] as any, {
+    D(MolScript.structureQuery.modifier.includeSurroundings, function structureQuery_modifier_includeSurroundings(ctx, xs) { return Queries.modifiers.includeSurroundings(xs[0] as any, {
         radius: xs['radius'](ctx),
         wholeResidues: !!(xs['as-whole-residues'] && xs['as-whole-residues'](ctx)),
         elementRadius: xs['atom-radius']
-    })(ctx)),
-    D(MolScript.structureQuery.modifier.wholeResidues, (ctx, xs) => Queries.modifiers.wholeResidues(xs[0] as any)(ctx)),
-    D(MolScript.structureQuery.modifier.union, (ctx, xs) => Queries.modifiers.union(xs[0] as any)(ctx)),
-    D(MolScript.structureQuery.modifier.expandProperty, (ctx, xs) => Queries.modifiers.expandProperty(xs[0] as any, xs['property'])(ctx)),
-    D(MolScript.structureQuery.modifier.exceptBy, (ctx, xs) => Queries.modifiers.exceptBy(xs[0] as any, xs['by'] as any)(ctx)),
-    D(MolScript.structureQuery.modifier.includeConnected, (ctx, xs) => Queries.modifiers.includeConnected({
+    })(ctx) }),
+    D(MolScript.structureQuery.modifier.wholeResidues, function structureQuery_modifier_wholeResidues(ctx, xs) { return Queries.modifiers.wholeResidues(xs[0] as any)(ctx) }),
+    D(MolScript.structureQuery.modifier.union, function structureQuery_modifier_union(ctx, xs) { return Queries.modifiers.union(xs[0] as any)(ctx) }),
+    D(MolScript.structureQuery.modifier.expandProperty, function structureQuery_modifier_expandProperty(ctx, xs) { return Queries.modifiers.expandProperty(xs[0] as any, xs['property'])(ctx) }),
+    D(MolScript.structureQuery.modifier.exceptBy, function structureQuery_modifier_exceptBy(ctx, xs) { return Queries.modifiers.exceptBy(xs[0] as any, xs['by'] as any)(ctx) }),
+    D(MolScript.structureQuery.modifier.includeConnected, function structureQuery_modifier_includeConnected(ctx, xs) { return Queries.modifiers.includeConnected({
         query: xs[0] as any,
         linkTest: xs['link-test'],
         wholeResidues: !!(xs['as-whole-residues'] && xs['as-whole-residues'](ctx)),
         layerCount: (xs['layer-count'] && xs['layer-count'](ctx)) || 1
-    })(ctx)),
+    })(ctx) }),
 
     // ============= COMBINATORS ================
 
@@ -326,9 +326,9 @@ const symbols = [
 
     ////////////////////////////////////
     // Internal
-    D(MolScript.internal.generator.bundleElement, (ctx, xs) => bundleElementImpl(xs.groupedUnits(ctx), xs.ranges(ctx), xs.set(ctx))),
-    D(MolScript.internal.generator.bundle, (ctx, xs) => bundleGenerator(xs.elements(ctx))(ctx)),
-    D(MolScript.internal.generator.current, (ctx, xs) => ctx.tryGetCurrentSelection()),
+    D(MolScript.internal.generator.bundleElement, function internal_generator_bundleElement(ctx, xs) { return bundleElementImpl(xs.groupedUnits(ctx), xs.ranges(ctx), xs.set(ctx)) }),
+    D(MolScript.internal.generator.bundle, function internal_generator_bundle(ctx, xs) { return bundleGenerator(xs.elements(ctx))(ctx) }),
+    D(MolScript.internal.generator.current, function internal_generator_current(ctx, xs) { return ctx.tryGetCurrentSelection() }),
 ];
 
 function atomProp(p: (e: StructureElement.Location) => any): (ctx: QueryContext, _: any) => any {