2010

pending completion

Build # 2010

Build Type

Pull #629

travis-ci-com

Committed by

web-flow

Commit Message

Merge 17df20daf into 2f1be5027

Pull Request Pull Request #629: Cherry-picked fixes from the error correction work

Run Details

12386 of 26033 branches covered (47.58%)

Branch coverage included in aggregate %.

57 of 83 new or added lines in 12 files covered. (68.67%)

266 existing lines in 20 files now uncovered.

28856 of 48937 relevant lines covered (58.97%)

452140.03 hits per line

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

90.43

/languages/thingtalk/dialogue_acts/results.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of Genie
//
// Copyright 2020 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 '../ast_manip';
import {
    ContextInfo
} from '../state_manip';
import { SlotBag } from '../slot_bag';

import {
    isInfoPhraseCompatibleWithResult,
    isSlotCompatibleWithResult,
} from './common';

const MAX_RESULTS = 3;

// a phrase that describes one or more results using slots
export interface ResultPhrase {
    ctx : ContextInfo;
    info : SlotBag;
    compatible : number[];
}

export function resultPhraseKeyFn(phrase : ResultPhrase) {
    return {
        functionName: phrase.ctx.currentFunction!.qualifiedName
    };
}

export function mergeResultPhrase(p1 : ResultPhrase, p2 : ResultPhrase) : ResultPhrase|null {
    assert(p1.ctx === p2.ctx);

    // check that both are compatible with some result, by intersecting
    // the compatible arrays
    const compatible : number[] = [];
    for (const resultIdx of p1.compatible) {
        if (p2.compatible.includes(resultIdx))
            compatible.push(resultIdx);
    }
    if (compatible.length === 0)
        return null;

    // this will also check that they don't both say the same thing
    const merged = SlotBag.merge(p1.info, p2.info);
    if (!merged)
        return null;

    return { ctx: p1.ctx, info: merged, compatible };
}

export function makeResultPhrase(ctx : ContextInfo, info : SlotBag) : ResultPhrase|null {
    if (info.schema !== null) {
        if (!C.isSameFunction(ctx.currentFunction!, info.schema))
            return null;
    }

    // check that the filter is compatible with at least one of the top 3 results
    const results = ctx.results!;
    const compatible : number[] = [];
    for (let i = 0; i < Math.min(MAX_RESULTS, results.length); i++) {
        if (isInfoPhraseCompatibleWithResult(results[i], info)) {
            compatible.push(i);
            break;
        }
    }
    if (compatible.length === 0)
        return null;

    if (info.schema !== null)
        return { ctx, info, compatible };

    const clone = info.clone();
    clone.schema = ctx.currentFunction;
    return { ctx, info: clone, compatible };
}

function addSlotToBagCloned(bag : SlotBag, filter : Ast.BooleanExpression) : [SlotBag, string[]]|null {
    if (filter instanceof Ast.AndBooleanExpression) {
        // we treat "serves Italian and Chinese" the same as "serves Italian or Chinese"

        let newBag : SlotBag|null = bag;
        const newSlots : string[] = [];
        for (const operand of filter.operands) {
            const added = addSlotToBagCloned(newBag, operand);
            if (!added)
                return null;
            newBag = added[0];
            newSlots.push(...added[1]);
        }
        return [newBag, newSlots];
    }
    if (!(filter instanceof Ast.AtomBooleanExpression))
        return null;

    const arg = bag.schema!.getArgument(filter.name);
    if (!arg || arg.is_input)
        return null;
    const ptype = arg.type;
    const vtype = filter.value.getType();
    if (filter.operator === 'contains' || filter.operator === 'contains~') {
        if (!ptype.equals(new Type.Array(vtype)))
            return null;
        const existing = bag.get(filter.name);
        if (existing) {
            assert(existing instanceof Ast.ArrayValue);
            if (existing.value.some((v) => v.equals(filter.value)))
                return null;
            existing.value.push(filter.value);
        } else {
            bag.set(filter.name, new Ast.Value.Array([filter.value]));
        }
        return [bag, [filter.name]];
    } else {
        if (filter.operator !== '==' && filter.operator !== '=~')
            return null;
        if (!ptype.equals(vtype))
            return null;
        if (bag.has(filter.name))
            return null;
        bag.set(filter.name, filter.value);
        return [bag, [filter.name]];
    }

}

export function addSlotToBag(bag : SlotBag, filter : C.FilterSlot) : [SlotBag, string[]]|null {
    const schema = bag.schema!;
    if (!C.isSameFunction(schema, filter.schema))
        return null;

    let name;
    if (filter.ast instanceof Ast.AndBooleanExpression) {
        const atom = filter.ast.operands[0];
        if (!(atom instanceof Ast.AtomBooleanExpression))
            return null;
        name = atom.name;
    } else {
        if (!(filter.ast instanceof Ast.AtomBooleanExpression))
            return null;
        name = filter.ast.name;
    }
    if (bag.has(name))
        return null;
    if (name === 'id')
        return null;

    const clone = bag.clone();
    return addSlotToBagCloned(clone, filter.ast);
}

export function addSlotToResultPhrase(phrase : ResultPhrase, filter : C.FilterSlot) : ResultPhrase|null {
    const added = addSlotToBag(phrase.info, filter);
    if (!added)
        return null;
    const [newBag, newSlots] = added;

    const compatible : number[] = [];
    const results = phrase.ctx.results!;
    for (const resultIdx of phrase.compatible) {
        const result = results[resultIdx];
        let good = true;
        for (const newSlot of newSlots) {
            if (!isSlotCompatibleWithResult(result, newSlot, newBag.get(newSlot)!)) {
                good = false;
                break;
            }
        }
        if (good)
            compatible.push(resultIdx);
    }
    if (compatible.length === 0)
        return null;
    return { ctx: phrase.ctx, info: newBag, compatible };
}

export interface DirectAnswerPhrase {
    result : ResultPhrase;
    name : Ast.Value;
    index : number;
}

export function directAnswerPhraseKeyFn(phrase : DirectAnswerPhrase) {
    return {
        index: phrase.index,
        type: phrase.name.getType()
    };
}

export function checkDirectAnswerPhrase(res : ResultPhrase, name : Ast.Value) : DirectAnswerPhrase|null {
    const results = res.ctx.results!;
    for (const resultIdx of res.compatible) {
        const result = results[resultIdx];
        if (result.value.id && result.value.id.equals(name))
            return { result: res, name, index: resultIdx };
    }
    return null;
}

export function makeFilterStyleDirectAnswerPhrase(ctx : ContextInfo, name : Ast.Value, filter : C.FilterSlot) : DirectAnswerPhrase|null {
    assert(C.isSameFunction(ctx.currentFunction!, filter.schema));
    const added = addSlotToBag(new SlotBag(ctx.currentFunction), filter);
    if (!added)
        return null;
    const [info,] = added;

    const results = ctx.results!;
    for (let i = 0; i < Math.min(MAX_RESULTS, results.length); i++) {
        const result = results[i];
        if (!result.value.id || !result.value.id.equals(name))
            continue;

        if (isInfoPhraseCompatibleWithResult(results[i], info)) {
            return {
                result: { ctx, info, compatible: [i] },
                name,
                index: i
            };
        }
    }

    return null;
}

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of Genie
4	//
5	// Copyright 2020 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
20
21
22	import assert from 'assert';	5✔
23	import { Ast, Type } from 'thingtalk';	5✔
24
25	import * as C from '../ast_manip';	5✔
26	import {
27	ContextInfo
28	} from '../state_manip';
29	import { SlotBag } from '../slot_bag';	5✔
30
31	import {	5✔
32	isInfoPhraseCompatibleWithResult,
33	isSlotCompatibleWithResult,
34	} from './common';
35
36	const MAX_RESULTS = 3;	5✔
37
38	// a phrase that describes one or more results using slots
39	export interface ResultPhrase {
40	ctx : ContextInfo;
41	info : SlotBag;
42	compatible : number[];
43	}
44
45	export function resultPhraseKeyFn(phrase : ResultPhrase) {	5✔
46	return {	19,589✔
47	functionName: phrase.ctx.currentFunction!.qualifiedName
48	};
49	}
50
51	export function mergeResultPhrase(p1 : ResultPhrase, p2 : ResultPhrase) : ResultPhrase\|null {	5✔
52	assert(p1.ctx === p2.ctx);	2,266✔
53
54	// check that both are compatible with some result, by intersecting
55	// the compatible arrays
56	const compatible : number[] = [];	2,266✔
57	for (const resultIdx of p1.compatible) {	2,266✔
58	if (p2.compatible.includes(resultIdx))	2,266✔
59	compatible.push(resultIdx);	2,073✔
60	}
61	if (compatible.length === 0)	2,266✔
62	return null;	193✔
63
64	// this will also check that they don't both say the same thing
65	const merged = SlotBag.merge(p1.info, p2.info);	2,073✔
66	if (!merged)	2,073✔
67	return null;	1,934✔
68
69	return { ctx: p1.ctx, info: merged, compatible };	139✔
70	}
71
72	export function makeResultPhrase(ctx : ContextInfo, info : SlotBag) : ResultPhrase\|null {	5✔
73	if (info.schema !== null) {	124,884✔
74	if (!C.isSameFunction(ctx.currentFunction!, info.schema))	32,054!
75	return null;	×
76	}
77
78	// check that the filter is compatible with at least one of the top 3 results
79	const results = ctx.results!;	124,884✔
80	const compatible : number[] = [];	124,884✔
81	for (let i = 0; i < Math.min(MAX_RESULTS, results.length); i++) {	124,884✔
82	if (isInfoPhraseCompatibleWithResult(results[i], info)) {	301,281✔
83	compatible.push(i);	869✔
84	break;	869✔
85	}
86	}
87	if (compatible.length === 0)	124,884✔
88	return null;	124,015✔
89
90	if (info.schema !== null)	869!
91	return { ctx, info, compatible };	869✔
92
UNCOV 93	const clone = info.clone();	×
UNCOV 94	clone.schema = ctx.currentFunction;	×
UNCOV 95	return { ctx, info: clone, compatible };	×
96	}
97
98	function addSlotToBagCloned(bag : SlotBag, filter : Ast.BooleanExpression) : [SlotBag, string[]]\|null {
99	if (filter instanceof Ast.AndBooleanExpression) {	1,508,611✔
100	// we treat "serves Italian and Chinese" the same as "serves Italian or Chinese"
101
102	let newBag : SlotBag\|null = bag;	302,586✔
103	const newSlots : string[] = [];	302,586✔
104	for (const operand of filter.operands) {	302,586✔
105	const added = addSlotToBagCloned(newBag, operand);	371,733✔
106	if (!added)	371,733✔
107	return null;	233,439✔
108	newBag = added[0];	138,294✔
109	newSlots.push(...added[1]);	138,294✔
110	}
111	return [newBag, newSlots];	69,147✔
112	}
113	if (!(filter instanceof Ast.AtomBooleanExpression))	1,206,025!
114	return null;	×
115
116	const arg = bag.schema!.getArgument(filter.name);	1,206,025✔
117	if (!arg \|\| arg.is_input)	1,206,025✔
118	return null;	67,902✔
119	const ptype = arg.type;	1,138,123✔
120	const vtype = filter.value.getType();	1,138,123✔
121	if (filter.operator === 'contains' \|\| filter.operator === 'contains~') {	1,138,123✔
122	if (!ptype.equals(new Type.Array(vtype)))	169,694!
123	return null;	×
124	const existing = bag.get(filter.name);	169,694✔
125	if (existing) {	169,694✔
126	assert(existing instanceof Ast.ArrayValue);	69,147✔
127	if (existing.value.some((v) => v.equals(filter.value)))	69,147!
128	return null;	×
129	existing.value.push(filter.value);	69,147✔
130	} else {
131	bag.set(filter.name, new Ast.Value.Array([filter.value]));	100,547✔
132	}
133	return [bag, [filter.name]];	169,694✔
134	} else {
135	if (filter.operator !== '==' && filter.operator !== '=~')	968,429✔
136	return null;	217,423✔
137	if (!ptype.equals(vtype))	751,006✔
138	return null;	1,617✔
139	if (bag.has(filter.name))	749,389!
140	return null;	×
141	bag.set(filter.name, filter.value);	749,389✔
142	return [bag, [filter.name]];	749,389✔
143	}
144
145	}
146
147	export function addSlotToBag(bag : SlotBag, filter : C.FilterSlot) : [SlotBag, string[]]\|null {	5✔
148	const schema = bag.schema!;	1,306,375✔
149	if (!C.isSameFunction(schema, filter.schema))	1,306,375!
150	return null;	×
151
152	let name;
153	if (filter.ast instanceof Ast.AndBooleanExpression) {	1,306,375✔
154	const atom = filter.ast.operands[0];	349,509✔
155	if (!(atom instanceof Ast.AtomBooleanExpression))	349,509!
156	return null;	×
157	name = atom.name;	349,509✔
158	} else {
159	if (!(filter.ast instanceof Ast.AtomBooleanExpression))	956,866!
160	return null;	×
161	name = filter.ast.name;	956,866✔
162	}
163	if (bag.has(name))	1,306,375✔
164	return null;	158,183✔
165	if (name === 'id')	1,148,192✔
166	return null;	11,314✔
167
168	const clone = bag.clone();	1,136,878✔
169	return addSlotToBagCloned(clone, filter.ast);	1,136,878✔
170	}
171
172	export function addSlotToResultPhrase(phrase : ResultPhrase, filter : C.FilterSlot) : ResultPhrase\|null {	5✔
173	const added = addSlotToBag(phrase.info, filter);	822,704✔
174	if (!added)	822,704✔
175	return null;	307,749✔
176	const [newBag, newSlots] = added;	514,955✔
177
178	const compatible : number[] = [];	514,955✔
179	const results = phrase.ctx.results!;	514,955✔
180	for (const resultIdx of phrase.compatible) {	514,955✔
181	const result = results[resultIdx];	514,955✔
182	let good = true;	514,955✔
183	for (const newSlot of newSlots) {	514,955✔
184	if (!isSlotCompatibleWithResult(result, newSlot, newBag.get(newSlot)!)) {	514,955✔
185	good = false;	500,525✔
186	break;	500,525✔
187	}
188	}
189	if (good)	514,955✔
190	compatible.push(resultIdx);	14,430✔
191	}
192	if (compatible.length === 0)	514,955✔
193	return null;	500,525✔
194	return { ctx: phrase.ctx, info: newBag, compatible };	14,430✔
195	}
196
197	export interface DirectAnswerPhrase {
198	result : ResultPhrase;
199	name : Ast.Value;
200	index : number;
201	}
202
203	export function directAnswerPhraseKeyFn(phrase : DirectAnswerPhrase) {	5✔
204	return {	10,902✔
205	index: phrase.index,
206	type: phrase.name.getType()
207	};
208	}
209
210	export function checkDirectAnswerPhrase(res : ResultPhrase, name : Ast.Value) : DirectAnswerPhrase\|null {	5✔
211	const results = res.ctx.results!;	5,092✔
212	for (const resultIdx of res.compatible) {	5,092✔
213	const result = results[resultIdx];	5,092✔
214	if (result.value.id && result.value.id.equals(name))	5,092✔
215	return { result: res, name, index: resultIdx };	3,278✔
216	}
217	return null;	1,814✔
218	}
219
220	export function makeFilterStyleDirectAnswerPhrase(ctx : ContextInfo, name : Ast.Value, filter : C.FilterSlot) : DirectAnswerPhrase\|null {	5✔
221	assert(C.isSameFunction(ctx.currentFunction!, filter.schema));	483,671✔
222	const added = addSlotToBag(new SlotBag(ctx.currentFunction), filter);	483,671✔
223	if (!added)	483,671✔
224	return null;	148,690✔
225	const [info,] = added;	334,981✔
226
227	const results = ctx.results!;	334,981✔
228	for (let i = 0; i < Math.min(MAX_RESULTS, results.length); i++) {	334,981✔
229	const result = results[i];	936,183✔
230	if (!result.value.id \|\| !result.value.id.equals(name))	936,183✔
231	continue;	243,903✔
232
233	if (isInfoPhraseCompatibleWithResult(results[i], info)) {	692,280✔
234	return {	4,685✔
235	result: { ctx, info, compatible: [i] },
236	name,
237	index: i
238	};
239	}
240	}
241
242	return null;	330,296✔
243	}

stanford-oval / genie-toolkit / 2010

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