2331

pending completion

Build # 2331

Build Type

Pull #755

travis-ci-com

Committed by

web-flow

Commit Message

Merge ad3495f09 into 6ca5dc5f6

Pull Request Pull Request #755: Add join templates to genie

Run Details

10147 of 20406 branches covered (49.73%)

Branch coverage included in aggregate %.

75 of 84 new or added lines in 7 files covered. (89.29%)

88 existing lines in 5 files now uncovered.

24196 of 40385 relevant lines covered (59.91%)

347320.24 hits per line

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

53.24

/lib/templates/dialogue_acts/search-questions.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, } from 'thingtalk';

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

import {
    ContextInfo,
    makeAgentReply,
    makeSimpleState,
    addQuery,
    addQueryAndAction,
} from '../state_manip';
import {
    queryRefinement,
    refineFilterToAnswerQuestion
} from './refinement-helpers';
import {
    isValidSearchQuestion,
    isSimpleFilterExpression,
    addParametersFromContext
} from './common';

export type PreciseSearchQuestionAnswer = [Ast.Expression, Ast.Invocation|null, boolean];

export function preciseSearchQuestionAnswerKeyFn([table, action, hasYes] : PreciseSearchQuestionAnswer) {
    return {
        functionName: table.schema!.qualifiedName,
        actionFunctionName: action ? action.schema!.qualifiedName : null
    };
}

function isGoodSearchQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
    const currentStmt = ctx.current!.stmt;
    if (!isValidSearchQuestion(currentStmt.lastQuery!, questions))
        return false;

    const ctxFilterTable = C.findFilterExpression(currentStmt.expression);
    if (!ctxFilterTable)
        return false;
    for (const q of questions) {
        if (C.filterUsesParam(ctxFilterTable.filter, q.name))
            return false;
    }
    return true;
}

function checkFilterPairForDisjunctiveQuestion(ctx : ContextInfo,
                                               f1 : C.FilterSlot,
                                               f2 : C.FilterSlot) : C.ParamSlot|null {
    if (!(f1.ast instanceof Ast.AtomBooleanExpression))
        return null;
    if (!(f2.ast instanceof Ast.AtomBooleanExpression))
        return null;
    if (!ctx.currentFunction!.is_list)
        return null;
    if (!C.isSameFunction(ctx.currentFunction!, f1.schema))
        return null;
    if (!C.isSameFunction(f1.schema, f2.schema))
        return null;
    if (f1.ast.name !== f2.ast.name)
        return null;
    if (!f1.ast.value.getType().equals(f2.ast.value.getType()))
        return null;
    if (f1.ast.value.equals(f2.ast.value))
        return null;
    const filterable = f1.schema.getArgument(f1.ast.name)!
        .getImplementationAnnotation<boolean>('filterable') ?? true;
    if (!filterable)
        return null;

    let good1 = false;
    let good2 = false;
    for (const result of ctx.results!) {
        const value = result.value[f1.ast.name];
        if (!value)
            return null;
        if (value.equals(f1.ast.value))
            good1 = true;
        if (value.equals(f2.ast.value))
            good2 = true;
        if (good1 && good2)
            break;
    }
    if (!good1 || !good2)
        return null;

    const symmetric = f1.schema.getArgument(f1.ast.name)!.getImplementationAnnotation<boolean>('symmetric') ?? false;
    return { schema: f1.schema, type: f1.ptype, name: f1.ast.name,
        filterable, symmetric, ast: new Ast.Value.VarRef(f1.ast.name) };
}

export function checkFilterPairForDisjunctiveQuestionWithConstant(ctx : ContextInfo,
                                                                  f1 : C.FilterSlot,
                                                                  c : Ast.Value) : C.ParamSlot|null {
    if (!(f1.ast instanceof Ast.AtomBooleanExpression))
        return null;
    const filterable = f1.schema.getArgument(f1.ast.name)!
        .getImplementationAnnotation<boolean>('filterable') ?? true;
    const symmetric = f1.schema.getArgument(f1.ast.name)!
        .getImplementationAnnotation<boolean>('symmetric') ?? false;
    const pslot = { schema: f1.schema, name: f1.ast.name, type: f1.ptype, filterable, symmetric,
        ast: new Ast.Value.VarRef(f1.ast.name) };
    const f2 = C.makeFilter(ctx.loader, pslot, f1.ast.operator, c);
    if (!f2)
        return null;
    return checkFilterPairForDisjunctiveQuestion(ctx, f1, f2);
}

function makeSearchQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
    if (!isGoodSearchQuestion(ctx, questions))
        return null;

    if (questions.length === 0)
        return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_generic_search_question', null));

    if (questions.length === 1) {
        const currentStmt = ctx.current!.stmt;
        const type = currentStmt.lastQuery!.schema!.getArgument(questions[0].name)!.type;
        return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_search_question', questions.map((q) => q.name)), null, type);
    }

    return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_search_question', questions.map((q) => q.name)));
}

class AnswersQuestionVisitor extends Ast.NodeVisitor {
    answersQuestion = false;
    constructor(private questions : string[]) {
        super();
    }

    visitAtomBooleanExpression(atom : Ast.AtomBooleanExpression) {
        if (this.questions.some((q) => q === atom.name))
            this.answersQuestion = true;
        return true;
    }
    visitDontCareBooleanExpression(atom : Ast.DontCareBooleanExpression) {
        if (this.questions.some((q) => q === atom.name))
            this.answersQuestion = true;
        return true;
    }
}

/**
 * Check if the table filters on the parameters `questions` (effectively providing a constraint on question)
 */
function isQueryAnswerValidForQuestion(table : Ast.Expression, questions : string[]) {
    assert(Array.isArray(questions));
    const visitor = new AnswersQuestionVisitor(questions);
    table.visit(visitor);
    return visitor.answersQuestion;
}

function preciseSearchQuestionAnswer(ctx : ContextInfo, [answerTable, answerAction, _bool] : [Ast.Expression, Ast.Invocation|null, boolean]) {
    const questions = ctx.state.dialogueActParam as string[];
    assert(questions === null || (Array.isArray(questions) && questions.length > 0 && questions.every((q) => typeof q === 'string')));
    if (questions !== null && !isQueryAnswerValidForQuestion(answerTable, questions))
        return null;
    if (!(answerTable instanceof Ast.FilterExpression))
        return null;

    if (!C.isSameFunction(answerTable.schema!, ctx.currentFunction!))
        return null;
    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;

    // TODO we need to push down the filter, if possible
    if (!isSimpleFilterExpression(answerTable))
        return null;

    if (answerAction !== null) {
        assert(answerAction instanceof Ast.Invocation);
        if (ctx.nextFunction !== null) {
            if (!C.isSameFunction(answerAction.schema!, ctx.nextFunction!))
                return null;

            // check that we don't fill the chain parameter through this path:
            // the chain parameter can only be filled if the agent shows the results
            for (const in_param of answerAction.in_params) {
                if (in_param.name === ctx.nextInfo!.chainParameter &&
                    !ctx.nextInfo!.chainParameterFilled)
                    return null;
            }

            const contextInvocation = C.getInvocation(ctx.next!);
            assert(contextInvocation instanceof Ast.Invocation);
            answerAction = addParametersFromContext(answerAction, contextInvocation);
        }
    }

    const newTable = queryRefinement(currentTable, answerTable.filter, refineFilterToAnswerQuestion, null);
    if (newTable === null)
        return null;
    if (answerAction !== null)
        return addQueryAndAction(ctx, 'execute', newTable, answerAction, 'accepted');
    else
        return addQuery(ctx, 'execute', newTable, 'accepted');
}


function impreciseSearchQuestionAnswer(ctx : ContextInfo, answer : C.FilterSlot|Ast.Value|'dontcare') {
    const questions = ctx.state.dialogueActParam as string[];
    if (questions === null || questions.length !== 1)
        return null;
    assert(Array.isArray(questions) && questions.length > 0 && questions.every((q) => typeof q === 'string'));

    let answerFilter : C.FilterSlot;
    if (answer === 'dontcare') {
        answerFilter = {
            schema: ctx.currentFunction!,
            ptype: ctx.currentFunction!.getArgType(questions[0])!,
            ast: new Ast.BooleanExpression.DontCare(null, questions[0])
        };
    } else if (answer instanceof Ast.Value) {
        assert(questions.length === 1);
        assert(answer instanceof Ast.Value);

        const arg = ctx.currentFunction!.getArgument(questions[0])!;
        const pslot = { schema: ctx.currentFunction!,
            type: arg.type,
            filterable: arg.getImplementationAnnotation<boolean>('filterable') ?? true,
            symmetric: arg.getImplementationAnnotation<boolean>('symmetric') ?? false,
            name: questions[0],
            ast: new Ast.Value.VarRef(questions[0]) };
        const newFilter = C.makeFilter(ctx.loader, pslot, '==', answer);
        if (newFilter === null)
            return null;
        answerFilter = newFilter;
    } else {
        answerFilter = answer;
        let pname : string;
        if (answer.ast instanceof Ast.AndBooleanExpression) {
            assert(answer.ast.operands.length === 2);
            const [op1, op2] = answer.ast.operands;
            assert(op1 instanceof Ast.AtomBooleanExpression
                   && op2 instanceof Ast.AtomBooleanExpression);
            assert(op1.name === op2.name &&
                   op1.value.getType().equals(op2.value.getType()));
            pname = op1.name;
        } else if (answer.ast instanceof Ast.NotBooleanExpression) {
            const inner = answer.ast.expr;
            assert(inner instanceof Ast.AtomBooleanExpression ||
                   inner instanceof Ast.DontCareBooleanExpression);
            pname = inner.name;
        } else {
            assert(answer.ast instanceof Ast.AtomBooleanExpression ||
                   answer.ast instanceof Ast.DontCareBooleanExpression);
            pname = answer.ast.name;
        }
        if (!questions.some((q) => q === pname))
            return null;
    }

    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    if (!C.checkFilter(currentTable, answerFilter))
        return null;

    const newTable = queryRefinement(currentTable, answerFilter.ast, refineFilterToAnswerQuestion, null);
    if (newTable === null)
        return null;
    return addQuery(ctx, 'execute', newTable, 'accepted');
}

export {
    checkFilterPairForDisjunctiveQuestion,
    makeSearchQuestion,
    preciseSearchQuestionAnswer,
    impreciseSearchQuestionAnswer
};

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';	97✔
23
24	import { Ast, } from 'thingtalk';	97✔
25
26	import * as C from '../ast_manip';	97✔
27
28	import {	97✔
29	ContextInfo,
30	makeAgentReply,
31	makeSimpleState,
32	addQuery,
33	addQueryAndAction,
34	} from '../state_manip';
35	import {	97✔
36	queryRefinement,
37	refineFilterToAnswerQuestion
38	} from './refinement-helpers';
39	import {	97✔
40	isValidSearchQuestion,
41	isSimpleFilterExpression,
42	addParametersFromContext
43	} from './common';
44
45	export type PreciseSearchQuestionAnswer = [Ast.Expression, Ast.Invocation\|null, boolean];
46
47	export function preciseSearchQuestionAnswerKeyFn([table, action, hasYes] : PreciseSearchQuestionAnswer) {	97✔
48	return {	52,096✔
49	functionName: table.schema!.qualifiedName,
50	actionFunctionName: action ? action.schema!.qualifiedName : null	52,096✔
51	};
52	}
53
54	function isGoodSearchQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
55	const currentStmt = ctx.current!.stmt;	39,127✔
56	if (!isValidSearchQuestion(currentStmt.lastQuery!, questions))	39,127✔
57	return false;	19,108✔
58
59	const ctxFilterTable = C.findFilterExpression(currentStmt.expression);	20,019✔
60	if (!ctxFilterTable)	20,019✔
61	return false;	13,478✔
62	for (const q of questions) {	6,541✔
63	if (C.filterUsesParam(ctxFilterTable.filter, q.name))	6,742✔
64	return false;	6,246✔
65	}
66	return true;	295✔
67	}
68
69	function checkFilterPairForDisjunctiveQuestion(ctx : ContextInfo,
70	f1 : C.FilterSlot,
71	f2 : C.FilterSlot) : C.ParamSlot\|null {
72	if (!(f1.ast instanceof Ast.AtomBooleanExpression))	×
73	return null;	×
74	if (!(f2.ast instanceof Ast.AtomBooleanExpression))	×
75	return null;	×
76	if (!ctx.currentFunction!.is_list)	×
77	return null;	×
78	if (!C.isSameFunction(ctx.currentFunction!, f1.schema))	×
79	return null;	×
80	if (!C.isSameFunction(f1.schema, f2.schema))	×
81	return null;	×
82	if (f1.ast.name !== f2.ast.name)	×
83	return null;	×
84	if (!f1.ast.value.getType().equals(f2.ast.value.getType()))	×
85	return null;	×
86	if (f1.ast.value.equals(f2.ast.value))	×
87	return null;	×
88	const filterable = f1.schema.getArgument(f1.ast.name)!	×
89	.getImplementationAnnotation<boolean>('filterable') ?? true;	×
90	if (!filterable)	×
91	return null;	×
92
93	let good1 = false;	×
94	let good2 = false;	×
95	for (const result of ctx.results!) {	×
96	const value = result.value[f1.ast.name];	×
97	if (!value)	×
98	return null;	×
99	if (value.equals(f1.ast.value))	×
100	good1 = true;	×
101	if (value.equals(f2.ast.value))	×
102	good2 = true;	×
103	if (good1 && good2)	×
104	break;	×
105	}
106	if (!good1 \|\| !good2)	×
107	return null;	×
108
NEW 109	const symmetric = f1.schema.getArgument(f1.ast.name)!.getImplementationAnnotation<boolean>('symmetric') ?? false;	×
UNCOV 110	return { schema: f1.schema, type: f1.ptype, name: f1.ast.name,	×
111	filterable, symmetric, ast: new Ast.Value.VarRef(f1.ast.name) };
112	}
113
114	export function checkFilterPairForDisjunctiveQuestionWithConstant(ctx : ContextInfo,	97✔
115	f1 : C.FilterSlot,
116	c : Ast.Value) : C.ParamSlot\|null {
117	if (!(f1.ast instanceof Ast.AtomBooleanExpression))	×
118	return null;	×
119	const filterable = f1.schema.getArgument(f1.ast.name)!	×
120	.getImplementationAnnotation<boolean>('filterable') ?? true;	×
NEW 121	const symmetric = f1.schema.getArgument(f1.ast.name)!	×
122	.getImplementationAnnotation<boolean>('symmetric') ?? false;	×
NEW 123	const pslot = { schema: f1.schema, name: f1.ast.name, type: f1.ptype, filterable, symmetric,	×
124	ast: new Ast.Value.VarRef(f1.ast.name) };
125	const f2 = C.makeFilter(ctx.loader, pslot, f1.ast.operator, c);	×
126	if (!f2)	×
127	return null;	×
128	return checkFilterPairForDisjunctiveQuestion(ctx, f1, f2);	×
129	}
130
131	function makeSearchQuestion(ctx : ContextInfo, questions : C.ParamSlot[]) {
132	if (!isGoodSearchQuestion(ctx, questions))	39,127✔
133	return null;	38,832✔
134
135	if (questions.length === 0)	295!
136	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_generic_search_question', null));	×
137
138	if (questions.length === 1) {	295✔
139	const currentStmt = ctx.current!.stmt;	129✔
140	const type = currentStmt.lastQuery!.schema!.getArgument(questions[0].name)!.type;	129✔
141	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_search_question', questions.map((q) => q.name)), null, type);	129✔
142	}
143
144	return makeAgentReply(ctx, makeSimpleState(ctx, 'sys_search_question', questions.map((q) => q.name)));	332✔
145	}
146
147	class AnswersQuestionVisitor extends Ast.NodeVisitor {
148	answersQuestion = false;	45,369✔
149	constructor(private questions : string[]) {	45,369✔
150	super();	45,369✔
151	}
152
153	visitAtomBooleanExpression(atom : Ast.AtomBooleanExpression) {
154	if (this.questions.some((q) => q === atom.name))	82,544✔
155	this.answersQuestion = true;	10,914✔
156	return true;	58,679✔
157	}
158	visitDontCareBooleanExpression(atom : Ast.DontCareBooleanExpression) {
159	if (this.questions.some((q) => q === atom.name))	×
160	this.answersQuestion = true;	×
161	return true;	×
162	}
163	}
164
165	/**
166	* Check if the table filters on the parameters `questions` (effectively providing a constraint on question)
167	*/
168	function isQueryAnswerValidForQuestion(table : Ast.Expression, questions : string[]) {
169	assert(Array.isArray(questions));	45,369✔
170	const visitor = new AnswersQuestionVisitor(questions);	45,369✔
171	table.visit(visitor);	45,369✔
172	return visitor.answersQuestion;	45,369✔
173	}
174
175	function preciseSearchQuestionAnswer(ctx : ContextInfo, [answerTable, answerAction, _bool] : [Ast.Expression, Ast.Invocation\|null, boolean]) {
176	const questions = ctx.state.dialogueActParam as string[];	45,369✔
177	assert(questions === null \|\| (Array.isArray(questions) && questions.length > 0 && questions.every((q) => typeof q === 'string')));	65,415✔
178	if (questions !== null && !isQueryAnswerValidForQuestion(answerTable, questions))	45,369✔
179	return null;	37,941✔
180	if (!(answerTable instanceof Ast.FilterExpression))	7,428!
181	return null;	×
182
183	if (!C.isSameFunction(answerTable.schema!, ctx.currentFunction!))	7,428!
184	return null;	×
185	const currentStmt = ctx.current!.stmt;	7,428✔
186	const currentTable = currentStmt.expression;	7,428✔
187
188	// TODO we need to push down the filter, if possible
189	if (!isSimpleFilterExpression(answerTable))	7,428!
190	return null;	×
191
192	if (answerAction !== null) {	7,428✔
193	assert(answerAction instanceof Ast.Invocation);	5✔
194	if (ctx.nextFunction !== null) {	5!
195	if (!C.isSameFunction(answerAction.schema!, ctx.nextFunction!))	×
196	return null;	×
197
198	// check that we don't fill the chain parameter through this path:
199	// the chain parameter can only be filled if the agent shows the results
200	for (const in_param of answerAction.in_params) {	×
201	if (in_param.name === ctx.nextInfo!.chainParameter &&	×
202	!ctx.nextInfo!.chainParameterFilled)
203	return null;	×
204	}
205
206	const contextInvocation = C.getInvocation(ctx.next!);	×
207	assert(contextInvocation instanceof Ast.Invocation);	×
208	answerAction = addParametersFromContext(answerAction, contextInvocation);	×
209	}
210	}
211
212	const newTable = queryRefinement(currentTable, answerTable.filter, refineFilterToAnswerQuestion, null);	7,428✔
213	if (newTable === null)	7,428✔
214	return null;	77✔
215	if (answerAction !== null)	7,351✔
216	return addQueryAndAction(ctx, 'execute', newTable, answerAction, 'accepted');	5✔
217	else
218	return addQuery(ctx, 'execute', newTable, 'accepted');	7,346✔
219	}
220
221
222	function impreciseSearchQuestionAnswer(ctx : ContextInfo, answer : C.FilterSlot\|Ast.Value\|'dontcare') {
223	const questions = ctx.state.dialogueActParam as string[];	699,280✔
224	if (questions === null \|\| questions.length !== 1)	699,280✔
225	return null;	505,681✔
226	assert(Array.isArray(questions) && questions.length > 0 && questions.every((q) => typeof q === 'string'));	193,599✔
227
228	let answerFilter : C.FilterSlot;
229	if (answer === 'dontcare') {	193,599!
230	answerFilter = {	×
231	schema: ctx.currentFunction!,
232	ptype: ctx.currentFunction!.getArgType(questions[0])!,
233	ast: new Ast.BooleanExpression.DontCare(null, questions[0])
234	};
235	} else if (answer instanceof Ast.Value) {	193,599✔
236	assert(questions.length === 1);	54,901✔
237	assert(answer instanceof Ast.Value);	54,901✔
238
239	const arg = ctx.currentFunction!.getArgument(questions[0])!;	54,901✔
240	const pslot = { schema: ctx.currentFunction!,	54,901✔
241	type: arg.type,
242	filterable: arg.getImplementationAnnotation<boolean>('filterable') ?? true,	164,703!
243	symmetric: arg.getImplementationAnnotation<boolean>('symmetric') ?? false,	164,703!
244	name: questions[0],
245	ast: new Ast.Value.VarRef(questions[0]) };
246	const newFilter = C.makeFilter(ctx.loader, pslot, '==', answer);	54,901✔
247	if (newFilter === null)	54,901✔
248	return null;	54,602✔
249	answerFilter = newFilter;	299✔
250	} else {
251	answerFilter = answer;	138,698✔
252	let pname : string;
253	if (answer.ast instanceof Ast.AndBooleanExpression) {	138,698✔
254	assert(answer.ast.operands.length === 2);	38,292✔
255	const [op1, op2] = answer.ast.operands;	38,292✔
256	assert(op1 instanceof Ast.AtomBooleanExpression	38,292✔
257	&& op2 instanceof Ast.AtomBooleanExpression);
258	assert(op1.name === op2.name &&	38,292✔
259	op1.value.getType().equals(op2.value.getType()));
260	pname = op1.name;	38,292✔
261	} else if (answer.ast instanceof Ast.NotBooleanExpression) {	100,406!
262	const inner = answer.ast.expr;	×
263	assert(inner instanceof Ast.AtomBooleanExpression \|\|	×
264	inner instanceof Ast.DontCareBooleanExpression);
265	pname = inner.name;	×
266	} else {
267	assert(answer.ast instanceof Ast.AtomBooleanExpression \|\|	100,406!
268	answer.ast instanceof Ast.DontCareBooleanExpression);
269	pname = answer.ast.name;	100,406✔
270	}
271	if (!questions.some((q) => q === pname))	138,698✔
272	return null;	127,574✔
273	}
274
275	const currentStmt = ctx.current!.stmt;	11,423✔
276	const currentTable = currentStmt.expression;	11,423✔
277	if (!C.checkFilter(currentTable, answerFilter))	11,423✔
278	return null;	8,905✔
279
280	const newTable = queryRefinement(currentTable, answerFilter.ast, refineFilterToAnswerQuestion, null);	2,518✔
281	if (newTable === null)	2,518!
282	return null;	×
283	return addQuery(ctx, 'execute', newTable, 'accepted');	2,518✔
284	}
285
286	export {
287	checkFilterPairForDisjunctiveQuestion,	97✔
288	makeSearchQuestion,	97✔
289	preciseSearchQuestionAnswer,	97✔
290	impreciseSearchQuestionAnswer	97✔
291	};

stanford-oval / genie-toolkit / 2331

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