2526

pending completion

Build # 2526

Build Type

Pull #805

travis-ci-com

Committed by

web-flow

Commit Message

Merge eaa14ec36 into f36b9938c

Pull Request Pull Request #805: Dialogue PL, part 1

Run Details

10172 of 21659 branches covered (46.96%)

Branch coverage included in aggregate %.

2370 of 3165 new or added lines in 70 files covered. (74.88%)

34 existing lines in 10 files now uncovered.

24797 of 42660 relevant lines covered (58.13%)

456516.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.62

/lib/transaction-dialogues/context-info.ts


// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of Genie
//
// Copyright 2020-2021 The Board of Trustees of the Leland Stanford Junior University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>

import assert from 'assert';
import { Ast, Type } from 'thingtalk';

import * as C from '../templates/ast_manip';

import { POLICY_NAME } from './metadata';

const LARGE_RESULT_THRESHOLD = 50;
function isLargeResultSet(result : Ast.DialogueHistoryResultList) : boolean {
    return result.more || !(result.count instanceof Ast.Value.Number) || result.count.value >= LARGE_RESULT_THRESHOLD;
}

function invertDirection(dir : 'asc'|'desc') : 'asc'|'desc' {
    if (dir === 'asc')
        return 'desc';
    else
        return 'asc';
}

function getSortName(value : Ast.Value) : string {
    if (value instanceof Ast.VarRefValue)
        return value.name;
    return C.getScalarExpressionName(value);
}

function getTableArgMinMax(table : Ast.Expression) : [string, string]|null {
    while (table instanceof Ast.ProjectionExpression)
        table = table.expression;

    // either an index of a sort, where the index is exactly 1 or -1
    // or a slice of a sort, with a base of 1 or -1, and a limit of 1
    // (both are equivalent and get normalized, but sometimes we don't run the normalization)
    if (table instanceof Ast.IndexExpression && table.expression instanceof Ast.SortExpression && table.indices.length === 1) {
        const index = table.indices[0];
        if (index instanceof Ast.Value.Number &&
            (index.value === 1 || index.value === -1))
            return [getSortName(table.expression.value), index.value === -1 ? invertDirection(table.expression.direction) : table.expression.direction];
    }

    if (table instanceof Ast.SliceExpression && table.expression instanceof Ast.SortExpression) {
        const { base, limit } = table;
        if (base instanceof Ast.Value.Number && (base.value === 1 || base.value === -1) &&
            limit instanceof Ast.Value.Number && limit.value === 1)
            return [getSortName(table.expression.value), base.value === -1 ? invertDirection(table.expression.direction) : table.expression.direction];
    }

    return null;
}

export class ResultInfo {
    hasStream : boolean;
    isTable : boolean;
    isQuestion : boolean;
    isAggregation : boolean;
    isList : boolean;
    argMinMaxField : [string, string]|null;
    projection : string[]|null;
    hasError : boolean;
    hasEmptyResult : boolean;
    hasSingleResult : boolean;
    hasLargeResult : boolean;
    idType : Type|null;

    constructor(state : Ast.DialogueState,
                item : Ast.DialogueHistoryItem) {
        assert(item.results !== null);

        const stmt = item.stmt;
        this.hasStream = stmt.stream !== null;

        this.isTable = stmt.last.schema!.functionType === 'query' &&
            (!this.hasStream || state.dialogueAct === 'notification');

        if (this.isTable) {
            const table = stmt.lastQuery!;
            this.isQuestion = !!(table instanceof Ast.ProjectionExpression
                || table instanceof Ast.IndexExpression
                || table instanceof Ast.AggregationExpression);
            this.isAggregation = table instanceof Ast.AggregationExpression;
            this.isList = stmt.expression.schema!.is_list;
            this.argMinMaxField = getTableArgMinMax(table);
            assert(this.argMinMaxField === null || this.isQuestion);
            this.projection = table instanceof Ast.ProjectionExpression ?
                C.getProjectionArguments(table) : null;
            if (this.projection)
                this.projection.sort();
        } else {
            this.isQuestion = false;
            this.isAggregation = false;
            this.isList = false;
            this.argMinMaxField = null;
            this.projection = null;
            if (state.dialogueAct === 'action_question')
                this.projection = state.dialogueActParam as string[];
        }
        this.hasError = item.results.error !== null;
        this.hasEmptyResult = !this.hasStream && item.results.results.length === 0;
        this.hasSingleResult = item.results.results.length === 1;
        this.hasLargeResult = isLargeResultSet(item.results);

        const id = stmt.last.schema!.getArgument('id');
        this.idType = id && !id.is_input ? id.type : null;
    }
}

export class NextStatementInfo {
    isAction : boolean;
    chainParameter : string|null;
    chainParameterFilled : boolean;
    isComplete : boolean;
    missingSlots : Ast.AbstractSlot[];

    constructor(currentItem : Ast.DialogueHistoryItem|null,
                resultInfo : ResultInfo|null,
                nextItem : Ast.DialogueHistoryItem) {
        const nextstmt = nextItem.stmt;

        this.isAction = !nextstmt.lastQuery;

        this.chainParameter = null;
        this.chainParameterFilled = false;
        this.isComplete = nextItem.isExecutable();
        this.missingSlots = [];

        for (const slot of nextItem.iterateSlots2()) {
            if (slot instanceof Ast.DeviceSelector)
                continue;
            if (slot.get() instanceof Ast.UndefinedValue)
                this.missingSlots.push(slot);
        }

        if (!this.isAction)
            return;

        assert(nextItem.stmt.expression.expressions.length === 1);
        const action = nextItem.stmt.first;
        assert(action instanceof Ast.InvocationExpression);

        if (!currentItem || !resultInfo || !resultInfo.isTable)
            return;

        const currentstmt = currentItem.stmt;
        const tableschema = currentstmt.expression.schema!;
        const idType = tableschema.getArgType('id');
        if (!idType)
            return;

        const invocation = action.invocation;
        const actionschema = invocation.schema!;
        for (const arg of actionschema.iterateArguments()) {
            if (!arg.is_input)
                continue;
            if (arg.type.equals(idType)) {
                this.chainParameter = arg.name;
                break;
            }
        }

        if (this.chainParameter === null)
            return;

        for (const in_param of invocation.in_params) {
            if (in_param.name === this.chainParameter && !in_param.value.isUndefined) {
                this.chainParameterFilled = true;
                break;
            }
        }
    }
}

function toID(value : Ast.Value|undefined) {
    if (value === undefined)
        return null;
    const jsValue = value.toJS();
    if (typeof jsValue === 'number')
        return jsValue;
    else if (jsValue === null || jsValue === undefined)
        return null;
    else
        return String(jsValue);
}

/**
 * This class contains additional information about the current dialogue state
 * that is specific to the transaction dialogues.
 *
 * All the information is already contained in the state itself, but this
 * class makes it faster and more convenient to access.
 *
 * It should not be used outside of the transaction dialogues.
 */
export class ContextInfo {
    state : Ast.DialogueState;
    currentFunction : Ast.FunctionDef|null;
    currentTableFunction : Ast.FunctionDef|null;
    resultInfo : ResultInfo|null;
    isMultiDomain : boolean;
    previousDomainIdx : number|null;
    currentIdx : number|null;
    nextFunction : Ast.FunctionDef|null;
    nextIdx : number|null;
    nextInfo : NextStatementInfo|null;
    aux : any;

    key : {
        currentFunction : string|null;
        nextFunction : string|null;
        currentTableFunction : string|null;

        // type of ID parameter of current result
        // this is usually the same as currentFunction, but can be null
        // the current function doesn't return an ID, and can be different
        // if the current function is not the primary query for this ID type
        // it is used to match names and contexts
        idType : Type|null;

        // IDs of the top 3 results (entity values or numeric IDs)
        id0 : string|number|null;
        id1 : string|number|null;
        id2 : string|number|null;

        // number of results
        resultLength : number;

        // aggregation result (for count)
        aggregationCount : number|null;

        is_monitorable : boolean;
    };

    private constructor(state : Ast.DialogueState,
                        currentTableSchema : Ast.FunctionDef|null,
                        currentFunctionSchema : Ast.FunctionDef|null,
                        resultInfo : ResultInfo|null,
                        previousDomainIdx : number|null,
                        currentIdx : number|null,
                        nextIdx : number|null,
                        nextFunctionSchema : Ast.FunctionDef|null,
                        nextInfo : NextStatementInfo|null,
                        aux : any = null) {
        this.state = state;

        assert(currentFunctionSchema === null || currentFunctionSchema instanceof Ast.FunctionDef);
        this.currentFunction = currentFunctionSchema;
        assert(currentTableSchema === null || currentTableSchema instanceof Ast.FunctionDef);
        this.currentTableFunction = currentTableSchema;

        this.resultInfo = resultInfo;
        this.isMultiDomain = previousDomainIdx !== null;
        this.previousDomainIdx = previousDomainIdx;
        this.currentIdx = currentIdx;

        assert(nextFunctionSchema === null || nextFunctionSchema instanceof Ast.FunctionDef);
        this.nextFunction = nextFunctionSchema;
        this.nextIdx = nextIdx;
        this.nextInfo = nextInfo;
        this.aux = aux;

        this.key = {
            currentFunction: this.currentFunction ? this.currentFunction.qualifiedName : null,
            nextFunction: this.nextFunction ? this.nextFunction.qualifiedName : null,
            currentTableFunction: this.currentTableFunction ? this.currentTableFunction.qualifiedName : null,

            idType: null,
            id0: null,
            id1: null,
            id2: null,
            resultLength: 0,

            aggregationCount: null,

            is_monitorable: this.currentFunction ? this.currentFunction.is_monitorable : false
        };
        if (this.resultInfo) {
            this.key.idType = this.resultInfo.idType;

            const results = this.results!;
            this.key.resultLength = results.length;
            if (results.length > 0)
                this.key.id0 = toID(results[0].value.id);
            if (results.length > 1)
                this.key.id1 = toID(results[1].value.id);
            if (results.length > 2)
                this.key.id2 = toID(results[2].value.id);

            if (this.resultInfo.isAggregation) {
                const count = results[0].value.count;
                if (count)
                    this.key.aggregationCount = count.toJS() as number;
            }
        }
    }

    static initial() {
        return new ContextInfo(new Ast.DialogueState(null, POLICY_NAME, 'sys_init', [], []),
            null, null, null, null, null, null, null, null);
    }

    private static _cache = new WeakMap<Ast.DialogueState, ContextInfo>();

    static get(state : Ast.DialogueState|null) : ContextInfo {
        if (state === null)
            return this.initial();
        const cached = this._cache.get(state);
        if (cached)
            return cached;

        let nextItemIdx = null, nextInfo = null, currentFunction = null, currentTableFunction = null,
            nextFunction = null, currentDevice = null, currentResultInfo = null,
            previousDomainItemIdx = null, currentItemIdx = null;
        let proposedSkip = 0;
        for (let idx = 0; idx < state.history.length; idx ++) {
            const item = state.history[idx];
            const itemschema = item.stmt.expression.schema!;
            const device = itemschema.class ? itemschema.class.name : null;
            if (currentDevice && device && device !== currentDevice)
                previousDomainItemIdx = currentItemIdx;
            if (item.confirm === 'proposed') {
                proposedSkip ++;
                continue;
            }
            if (item.results === null) {
                nextItemIdx = idx;
                nextFunction = itemschema;
                nextInfo = new NextStatementInfo(
                    currentItemIdx !== null ? state.history[currentItemIdx] : null,
                    currentResultInfo, item);
                break;
            }

            // proposed items must come after the current item
            // (but they can come before or after the next item, depending on what we're proposing)
            assert(proposedSkip === 0);

            currentDevice = device;
            currentFunction = itemschema;

            const stmt = item.stmt;
            const lastQuery = stmt.lastQuery;
            if (lastQuery)
                currentTableFunction = lastQuery.schema;
            currentItemIdx = idx;
            currentResultInfo = new ResultInfo(state, item);
        }
        if (nextItemIdx !== null)
            assert(nextInfo);
        if (nextItemIdx !== null && currentItemIdx !== null)
            assert(nextItemIdx === currentItemIdx + 1 + proposedSkip);
        if (previousDomainItemIdx !== null)
            assert(currentItemIdx !== null && previousDomainItemIdx <= currentItemIdx);

        const newCtx = new ContextInfo(state, currentTableFunction, currentFunction, currentResultInfo,
            previousDomainItemIdx, currentItemIdx, nextItemIdx, nextFunction, nextInfo);
        this._cache.set(state, newCtx);
        return newCtx;
    }

    toString() : string {
        return `ContextInfo(${this.state.prettyprint()})`;
    }

    get results() {
        if (this.currentIdx !== null)
            return this.state.history[this.currentIdx].results!.results;
        return null;
    }

    get error() {
        if (this.currentIdx !== null)
            return this.state.history[this.currentIdx].results!.error;
        return null;
    }

    get previousDomain() {
        return this.previousDomainIdx !== null ? this.state.history[this.previousDomainIdx] : null;
    }

    get current() {
        return this.currentIdx !== null ? this.state.history[this.currentIdx] : null;
    }

    get next() {
        return this.nextIdx !== null ? this.state.history[this.nextIdx] : null;
    }

    clone() {
        return new ContextInfo(
            this.state.clone(),
            this.currentTableFunction,
            this.currentFunction,
            this.resultInfo,
            this.previousDomainIdx, this.currentIdx,
            this.nextIdx, this.nextFunction, this.nextInfo,
            this.aux
        );
    }
}

export function contextKeyFn(ctx : ContextInfo) {
    return ctx.key;
}

1
2	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
3	//
4	// This file is part of Genie
5	//
6	// Copyright 2020-2021 The Board of Trustees of the Leland Stanford Junior University
7	//
8	// Licensed under the Apache License, Version 2.0 (the "License");
9	// you may not use this file except in compliance with the License.
10	// You may obtain a copy of the License at
11	//
12	// http://www.apache.org/licenses/LICENSE-2.0
13	//
14	// Unless required by applicable law or agreed to in writing, software
15	// distributed under the License is distributed on an "AS IS" BASIS,
16	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17	// See the License for the specific language governing permissions and
18	// limitations under the License.
19	//
20	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
21
22	import assert from 'assert';	108✔
23	import { Ast, Type } from 'thingtalk';	108✔
24
25	import * as C from '../templates/ast_manip';	108✔
26
27	import { POLICY_NAME } from './metadata';	108✔
28
29	const LARGE_RESULT_THRESHOLD = 50;	108✔
30	function isLargeResultSet(result : Ast.DialogueHistoryResultList) : boolean {
31	return result.more \|\| !(result.count instanceof Ast.Value.Number) \|\| result.count.value >= LARGE_RESULT_THRESHOLD;	68,908✔
32	}
33
34	function invertDirection(dir : 'asc'\|'desc') : 'asc'\|'desc' {
NEW 35	if (dir === 'asc')	×
NEW 36	return 'desc';	×
37	else
NEW 38	return 'asc';	×
39	}
40
41	function getSortName(value : Ast.Value) : string {
42	if (value instanceof Ast.VarRefValue)	5,412✔
43	return value.name;	4,734✔
44	return C.getScalarExpressionName(value);	678✔
45	}
46
47	function getTableArgMinMax(table : Ast.Expression) : [string, string]\|null {
48	while (table instanceof Ast.ProjectionExpression)	45,986✔
49	table = table.expression;	2,094✔
50
51	// either an index of a sort, where the index is exactly 1 or -1
52	// or a slice of a sort, with a base of 1 or -1, and a limit of 1
53	// (both are equivalent and get normalized, but sometimes we don't run the normalization)
54	if (table instanceof Ast.IndexExpression && table.expression instanceof Ast.SortExpression && table.indices.length === 1) {	45,986✔
55	const index = table.indices[0];	5,412✔
56	if (index instanceof Ast.Value.Number &&	5,412!
57	(index.value === 1 \|\| index.value === -1))
58	return [getSortName(table.expression.value), index.value === -1 ? invertDirection(table.expression.direction) : table.expression.direction];	5,412!
59	}
60
61	if (table instanceof Ast.SliceExpression && table.expression instanceof Ast.SortExpression) {	40,574✔
62	const { base, limit } = table;	2✔
63	if (base instanceof Ast.Value.Number && (base.value === 1 \|\| base.value === -1) &&	2!
64	limit instanceof Ast.Value.Number && limit.value === 1)
NEW 65	return [getSortName(table.expression.value), base.value === -1 ? invertDirection(table.expression.direction) : table.expression.direction];	×
66	}
67
68	return null;	40,574✔
69	}
70
71	export class ResultInfo {	108✔
72	hasStream : boolean;
73	isTable : boolean;
74	isQuestion : boolean;
75	isAggregation : boolean;
76	isList : boolean;
77	argMinMaxField : [string, string]\|null;
78	projection : string[]\|null;
79	hasError : boolean;
80	hasEmptyResult : boolean;
81	hasSingleResult : boolean;
82	hasLargeResult : boolean;
83	idType : Type\|null;
84
85	constructor(state : Ast.DialogueState,
86	item : Ast.DialogueHistoryItem) {
87	assert(item.results !== null);	68,908✔
88
89	const stmt = item.stmt;	68,908✔
90	this.hasStream = stmt.stream !== null;	68,908✔
91
92	this.isTable = stmt.last.schema!.functionType === 'query' &&	68,908✔
93	(!this.hasStream \|\| state.dialogueAct === 'notification');
94
95	if (this.isTable) {	68,908✔
96	const table = stmt.lastQuery!;	45,986✔
97	this.isQuestion = !!(table instanceof Ast.ProjectionExpression	45,986✔
98	\|\| table instanceof Ast.IndexExpression
99	\|\| table instanceof Ast.AggregationExpression);
100	this.isAggregation = table instanceof Ast.AggregationExpression;	45,986✔
101	this.isList = stmt.expression.schema!.is_list;	45,986✔
102	this.argMinMaxField = getTableArgMinMax(table);	45,986✔
103	assert(this.argMinMaxField === null \|\| this.isQuestion);	45,986✔
104	this.projection = table instanceof Ast.ProjectionExpression ?	45,986✔
105	C.getProjectionArguments(table) : null;	45,986✔
106	if (this.projection)	45,986✔
107	this.projection.sort();	2,094✔
108	} else {
109	this.isQuestion = false;	22,922✔
110	this.isAggregation = false;	22,922✔
111	this.isList = false;	22,922✔
112	this.argMinMaxField = null;	22,922✔
113	this.projection = null;	22,922✔
114	if (state.dialogueAct === 'action_question')	22,922!
NEW 115	this.projection = state.dialogueActParam as string[];	×
116	}
117	this.hasError = item.results.error !== null;	68,908✔
118	this.hasEmptyResult = !this.hasStream && item.results.results.length === 0;	68,908✔
119	this.hasSingleResult = item.results.results.length === 1;	68,908✔
120	this.hasLargeResult = isLargeResultSet(item.results);	68,908✔
121
122	const id = stmt.last.schema!.getArgument('id');	68,908✔
123	this.idType = id && !id.is_input ? id.type : null;	68,908✔
124	}
125	}
126
127	export class NextStatementInfo {	108✔
128	isAction : boolean;
129	chainParameter : string\|null;
130	chainParameterFilled : boolean;
131	isComplete : boolean;
132	missingSlots : Ast.AbstractSlot[];
133
134	constructor(currentItem : Ast.DialogueHistoryItem\|null,
135	resultInfo : ResultInfo\|null,
136	nextItem : Ast.DialogueHistoryItem) {
137	const nextstmt = nextItem.stmt;	2,421✔
138
139	this.isAction = !nextstmt.lastQuery;	2,421✔
140
141	this.chainParameter = null;	2,421✔
142	this.chainParameterFilled = false;	2,421✔
143	this.isComplete = nextItem.isExecutable();	2,421✔
144	this.missingSlots = [];	2,421✔
145
146	for (const slot of nextItem.iterateSlots2()) {	2,421✔
147	if (slot instanceof Ast.DeviceSelector)	11,684✔
148	continue;	2,462✔
149	if (slot.get() instanceof Ast.UndefinedValue)	9,222✔
150	this.missingSlots.push(slot);	5,454✔
151	}
152
153	if (!this.isAction)	2,421✔
154	return;	88✔
155
156	assert(nextItem.stmt.expression.expressions.length === 1);	2,333✔
157	const action = nextItem.stmt.first;	2,333✔
158	assert(action instanceof Ast.InvocationExpression);	2,333✔
159
160	if (!currentItem \|\| !resultInfo \|\| !resultInfo.isTable)	2,333✔
161	return;	417✔
162
163	const currentstmt = currentItem.stmt;	1,916✔
164	const tableschema = currentstmt.expression.schema!;	1,916✔
165	const idType = tableschema.getArgType('id');	1,916✔
166	if (!idType)	1,916!
NEW 167	return;	×
168
169	const invocation = action.invocation;	1,916✔
170	const actionschema = invocation.schema!;	1,916✔
171	for (const arg of actionschema.iterateArguments()) {	1,916✔
172	if (!arg.is_input)	1,916!
NEW 173	continue;	×
174	if (arg.type.equals(idType)) {	1,916!
175	this.chainParameter = arg.name;	1,916✔
176	break;	1,916✔
177	}
178	}
179
180	if (this.chainParameter === null)	1,916!
NEW 181	return;	×
182
183	for (const in_param of invocation.in_params) {	1,916✔
184	if (in_param.name === this.chainParameter && !in_param.value.isUndefined) {	5,739!
NEW 185	this.chainParameterFilled = true;	×
NEW 186	break;	×
187	}
188	}
189	}
190	}
191
192	function toID(value : Ast.Value\|undefined) {
193	if (value === undefined)	129,598✔
194	return null;	45,325✔
195	const jsValue = value.toJS();	84,273✔
196	if (typeof jsValue === 'number')	84,273✔
197	return jsValue;	4✔
198	else if (jsValue === null \|\| jsValue === undefined)	84,269!
NEW 199	return null;	×
200	else
201	return String(jsValue);	84,269✔
202	}
203
204	/**
205	* This class contains additional information about the current dialogue state
206	* that is specific to the transaction dialogues.
207	*
208	* All the information is already contained in the state itself, but this
209	* class makes it faster and more convenient to access.
210	*
211	* It should not be used outside of the transaction dialogues.
212	*/
213	export class ContextInfo {	108✔
214	state : Ast.DialogueState;
215	currentFunction : Ast.FunctionDef\|null;
216	currentTableFunction : Ast.FunctionDef\|null;
217	resultInfo : ResultInfo\|null;
218	isMultiDomain : boolean;
219	previousDomainIdx : number\|null;
220	currentIdx : number\|null;
221	nextFunction : Ast.FunctionDef\|null;
222	nextIdx : number\|null;
223	nextInfo : NextStatementInfo\|null;
224	aux : any;
225
226	key : {
227	currentFunction : string\|null;
228	nextFunction : string\|null;
229	currentTableFunction : string\|null;
230
231	// type of ID parameter of current result
232	// this is usually the same as currentFunction, but can be null
233	// the current function doesn't return an ID, and can be different
234	// if the current function is not the primary query for this ID type
235	// it is used to match names and contexts
236	idType : Type\|null;
237
238	// IDs of the top 3 results (entity values or numeric IDs)
239	id0 : string\|number\|null;
240	id1 : string\|number\|null;
241	id2 : string\|number\|null;
242
243	// number of results
244	resultLength : number;
245
246	// aggregation result (for count)
247	aggregationCount : number\|null;
248
249	is_monitorable : boolean;
250	};
251
252	private constructor(state : Ast.DialogueState,
253	currentTableSchema : Ast.FunctionDef\|null,
254	currentFunctionSchema : Ast.FunctionDef\|null,
255	resultInfo : ResultInfo\|null,
256	previousDomainIdx : number\|null,
257	currentIdx : number\|null,
258	nextIdx : number\|null,
259	nextFunctionSchema : Ast.FunctionDef\|null,
260	nextInfo : NextStatementInfo\|null,
261	aux : any = null) {	74,060✔
262	this.state = state;	74,060✔
263
264	assert(currentFunctionSchema === null \|\| currentFunctionSchema instanceof Ast.FunctionDef);	74,060✔
265	this.currentFunction = currentFunctionSchema;	74,060✔
266	assert(currentTableSchema === null \|\| currentTableSchema instanceof Ast.FunctionDef);	74,060✔
267	this.currentTableFunction = currentTableSchema;	74,060✔
268
269	this.resultInfo = resultInfo;	74,060✔
270	this.isMultiDomain = previousDomainIdx !== null;	74,060✔
271	this.previousDomainIdx = previousDomainIdx;	74,060✔
272	this.currentIdx = currentIdx;	74,060✔
273
274	assert(nextFunctionSchema === null \|\| nextFunctionSchema instanceof Ast.FunctionDef);	74,060✔
275	this.nextFunction = nextFunctionSchema;	74,060✔
276	this.nextIdx = nextIdx;	74,060✔
277	this.nextInfo = nextInfo;	74,060✔
278	this.aux = aux;	74,060✔
279
280	this.key = {	74,060✔
281	currentFunction: this.currentFunction ? this.currentFunction.qualifiedName : null,	74,060✔
282	nextFunction: this.nextFunction ? this.nextFunction.qualifiedName : null,	74,060✔
283	currentTableFunction: this.currentTableFunction ? this.currentTableFunction.qualifiedName : null,	74,060✔
284
285	idType: null,
286	id0: null,
287	id1: null,
288	id2: null,
289	resultLength: 0,
290
291	aggregationCount: null,
292
293	is_monitorable: this.currentFunction ? this.currentFunction.is_monitorable : false	74,060✔
294	};
295	if (this.resultInfo) {	74,060✔
296	this.key.idType = this.resultInfo.idType;	68,736✔
297
298	const results = this.results!;	68,736✔
299	this.key.resultLength = results.length;	68,736✔
300	if (results.length > 0)	68,736✔
301	this.key.id0 = toID(results[0].value.id);	55,719✔
302	if (results.length > 1)	68,736✔
303	this.key.id1 = toID(results[1].value.id);	37,760✔
304	if (results.length > 2)	68,736✔
305	this.key.id2 = toID(results[2].value.id);	36,119✔
306
307	if (this.resultInfo.isAggregation) {	68,736✔
308	const count = results[0].value.count;	270✔
309	if (count)	270✔
310	this.key.aggregationCount = count.toJS() as number;	268✔
311	}
312	}
313	}
314
315	static initial() {
316	return new ContextInfo(new Ast.DialogueState(null, POLICY_NAME, 'sys_init', [], []),	3,802✔
317	null, null, null, null, null, null, null, null);
318	}
319
320	private static _cache = new WeakMap<Ast.DialogueState, ContextInfo>();	108✔
321
322	static get(state : Ast.DialogueState\|null) : ContextInfo {
323	if (state === null)	71,835!
NEW 324	return this.initial();	×
325	const cached = this._cache.get(state);	71,835✔
326	if (cached)	71,835✔
327	return cached;	1,577✔
328
329	let nextItemIdx = null, nextInfo = null, currentFunction = null, currentTableFunction = null,	70,258✔
330	nextFunction = null, currentDevice = null, currentResultInfo = null,	70,258✔
331	previousDomainItemIdx = null, currentItemIdx = null;	70,258✔
332	let proposedSkip = 0;	70,258✔
333	for (let idx = 0; idx < state.history.length; idx ++) {	70,258✔
334	const item = state.history[idx];	77,463✔
335	const itemschema = item.stmt.expression.schema!;	77,463✔
336	const device = itemschema.class ? itemschema.class.name : null;	77,463✔
337	if (currentDevice && device && device !== currentDevice)	77,463✔
338	previousDomainItemIdx = currentItemIdx;	6✔
339	if (item.confirm === 'proposed') {	77,463✔
340	proposedSkip ++;	6,139✔
341	continue;	6,139✔
342	}
343	if (item.results === null) {	71,324✔
344	nextItemIdx = idx;	2,421✔
345	nextFunction = itemschema;	2,421✔
346	nextInfo = new NextStatementInfo(	2,421✔
347	currentItemIdx !== null ? state.history[currentItemIdx] : null,	2,421✔
348	currentResultInfo, item);
349	break;	2,421✔
350	}
351
352	// proposed items must come after the current item
353	// (but they can come before or after the next item, depending on what we're proposing)
354	assert(proposedSkip === 0);	68,903✔
355
356	currentDevice = device;	68,903✔
357	currentFunction = itemschema;	68,903✔
358
359	const stmt = item.stmt;	68,903✔
360	const lastQuery = stmt.lastQuery;	68,903✔
361	if (lastQuery)	68,903✔
362	currentTableFunction = lastQuery.schema;	65,701✔
363	currentItemIdx = idx;	68,903✔
364	currentResultInfo = new ResultInfo(state, item);	68,903✔
365	}
366	if (nextItemIdx !== null)	70,258✔
367	assert(nextInfo);	2,421✔
368	if (nextItemIdx !== null && currentItemIdx !== null)	70,258✔
369	assert(nextItemIdx === currentItemIdx + 1 + proposedSkip);	1,916✔
370	if (previousDomainItemIdx !== null)	70,258✔
371	assert(currentItemIdx !== null && previousDomainItemIdx <= currentItemIdx);	6✔
372
373	const newCtx = new ContextInfo(state, currentTableFunction, currentFunction, currentResultInfo,	70,258✔
374	previousDomainItemIdx, currentItemIdx, nextItemIdx, nextFunction, nextInfo);
375	this._cache.set(state, newCtx);	70,258✔
376	return newCtx;	70,258✔
377	}
378
379	toString() : string {
NEW 380	return `ContextInfo(${this.state.prettyprint()})`;	×
381	}
382
383	get results() {
384	if (this.currentIdx !== null)	1,563,109!
385	return this.state.history[this.currentIdx].results!.results;	1,563,109✔
NEW 386	return null;	×
387	}
388
389	get error() {
390	if (this.currentIdx !== null)	115!
391	return this.state.history[this.currentIdx].results!.error;	115✔
NEW 392	return null;	×
393	}
394
395	get previousDomain() {
NEW 396	return this.previousDomainIdx !== null ? this.state.history[this.previousDomainIdx] : null;	×
397	}
398
399	get current() {
400	return this.currentIdx !== null ? this.state.history[this.currentIdx] : null;	2,435,152✔
401	}
402
403	get next() {
404	return this.nextIdx !== null ? this.state.history[this.nextIdx] : null;	85,044✔
405	}
406
407	clone() {
NEW 408	return new ContextInfo(	×
409	this.state.clone(),
410	this.currentTableFunction,
411	this.currentFunction,
412	this.resultInfo,
413	this.previousDomainIdx, this.currentIdx,
414	this.nextIdx, this.nextFunction, this.nextInfo,
415	this.aux
416	);
417	}
418	}
419
420	export function contextKeyFn(ctx : ContextInfo) {	108✔
421	return ctx.key;	826✔
422	}

stanford-oval / genie-toolkit / 2526

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous