private Optional <ProgramSet> LearnChildren(PremSpec <TInput, IEnumerable <SyntaxNode> > spec) { Debug.Assert(spec.Forall((i, o) => o.Any()) && spec.Identical((i, o) => o.Count())); // First synthesize the first child. var childSpec = spec.MapOutputs((i, o) => o.First()); var childSpace = LearnTree(childSpec); if (childSpace.IsEmpty) { return(Optional <ProgramSet> .Nothing); } // Suppose no more children, then this is the base case. if (!spec.Forall((i, o) => o.Rest().Any())) { return(ProgramSet.Join(Op(nameof(Semantics.Child)), childSpace).Some()); } #if DEBUG Debug.Assert(spec.Forall((i, o) => o.Rest().Any())); #endif // Then synthesize the rest, inductively. var childrenSpec = spec.MapOutputs((i, o) => o.Rest()); var childrenSpace = LearnChildren(childrenSpec); if (!childrenSpace.HasValue || childrenSpace.Value.IsEmpty) { return(Optional <ProgramSet> .Nothing); } return(ProgramSet.Join(Op(nameof(Semantics.Children)), childSpace, childrenSpace.Value).Some()); }
private Optional <ProgramSet> LearnAppend(PremSpec <TInput, IEnumerable <SyntaxNode> > spec, int k) { Debug.Assert(spec.Forall((i, o) => o.Any())); // Synthesize param `frontParent`. var frontSpec = spec.MapOutputs((i, o) => o.DropLast(k)); var parents = frontSpec.MapOutputs((i, o) => { var candidates = o.MapI((index, c) => c.MatchedParents(index)); return(candidates.Any() ? candidates.SetIntersect() : new HashSet <SyntaxNode>()); }); if (parents.Forall((i, ps) => ps.Any())) { #if DEBUG if (parents.Any((i, ps) => ps.Count > 1)) { Log.Debug("Possibly multiple ways for frontParentSpec"); } #endif var frontParentSpec = parents.MapOutputs((i, ps) => ps.First() as SyntaxNode); #if DEBUG Log.Tree("front parent |- {0}", frontParentSpec); Log.IncIndent(); #endif var frontParentSpace = LearnRef(frontParentSpec); #if DEBUG Log.DecIndent(); #endif if (frontParentSpace.IsEmpty) { return(Optional <ProgramSet> .Nothing); } // Synthesize param `tail`. var childrenSpec = spec.MapOutputs((i, o) => o.Last(k)); #if DEBUG Log.Tree("append children |- {0}", childrenSpec); Log.IncIndent(); #endif var childrenSpace = LearnChildren(childrenSpec); #if DEBUG Log.DecIndent(); #endif if (!childrenSpace.HasValue || childrenSpace.Value.IsEmpty) { return(Optional <ProgramSet> .Nothing); } return(ProgramSet.Join(Op(nameof(Semantics.Append)), frontParentSpace, childrenSpace.Value).Some()); } return(Optional <ProgramSet> .Nothing); }
/// <summary> /// Learning a `Lift`, i.e. node lifter, that is consistent with the specification. /// This method only identifies the lowest scope that covers all examples. /// </summary> /// <param name="spec">Specification of the form: input -> node to be referenced.</param> /// <param name="sourceSpec">Constraint on the `source` of `Lift`: input -> source node.</param> /// <param name="source">The program which constructs the `source`.</param> /// <param name="scopeSpec">Output. Specification for learning `scope`: input -> scope root.</param> /// <returns>Consistent program (if exist) or nothing.</returns> private Optional <ProgramNode> LearnLift(PremSpec <TInput, SyntaxNode> spec, PremSpec <TInput, Leaf> sourceSpec, ProgramNode source, out PremSpec <TInput, Node> scopeSpec) { scopeSpec = spec.MapOutputs((i, o) => CommonAncestor.LCA(o, sourceSpec[i])); while (scopeSpec.Forall((i, o) => o != null)) { Log.Tree("iter scopeSpec = {0}", scopeSpec); Label label; int k; if (scopeSpec.Identical((i, o) => o.label, out label)) { if (scopeSpec.Identical((i, o) => sourceSpec[i].CountAncestorWhere( n => n.label.Equals(label), o.id), out k)) { return(Lift(source, label, k).Some()); } // else: lift more, simultaneously scopeSpec = scopeSpec.MapOutputs((i, o) => o.parent); continue; } // labels are different: try lift all of them to the highest var highest = scopeSpec.ArgMin(p => p.Value.depth); label = highest.Value.label; if (!scopeSpec.Forall((i, o) => i.Equals(highest.Key) ? true : o.Ancestors().Any(n => n.label.Equals(label)))) { // Log.Debug("Lift: impossible to lift all of them to the highest"); return(Optional <ProgramNode> .Nothing); } scopeSpec = scopeSpec.MapOutputs((i, o) => i.Equals(highest.Key) ? o : o.Ancestors().First(n => n.label.Equals(label))); } Log.Debug("Lift: loop ends"); return(Optional <ProgramNode> .Nothing); }
/// <summary> /// Learning a set of selectors that are consistent with the specification. /// </summary> /// <param name="spec">Specification of the form: input -> node to be referenced.</param> /// <param name="scopeSpec">Specification for learned scopes (`node`s): input -> scope root.</param> /// <param name="scopeSpace">The programs that construct the scope (`node`).</param> /// <returns>Consistent programs (if exist) or emptyset.</returns> private ProgramSet LearnSelect(PremSpec <TInput, SyntaxNode> spec, PremSpec <TInput, Node> scopeSpec, ProgramSet scopeSpace) { var spaces = new List <ProgramSet>(); #if DEBUG Log.Tree("selectors"); Log.IncIndent(); #endif // Option 1: select inside one of subscope, say one of the child of the scope root. // REQUIRE: expected node in scope[index] for some index for all examples. int index; if (spec.Identical((i, o) => scopeSpec[i].Locate(o), out index) && index >= 0) { var indexSpace = ProgramSet.List(Symbol("index"), Index(index)); var subscopeSpace = ProgramSet.Join(Op(nameof(Semantics.Sub)), scopeSpace, indexSpace); #if DEBUG Log.Tree("in subscope {0}", index); Log.IncIndent(); #endif spaces.Add(LearnSelectInScope(spec, scopeSpec.MapOutputs((i, o) => o.GetChild(index)), subscopeSpace)); #if DEBUG Log.DecIndent(); #endif } // Option 2: select inside the entire scope. // NO REQUIREMENT. #if DEBUG Log.Tree("in entire scope"); Log.IncIndent(); #endif spaces.Add(LearnSelectInScope(spec, scopeSpec.MapOutputs((i, o) => (SyntaxNode)o), scopeSpace)); #if DEBUG Log.DecIndent(); Log.DecIndent(); #endif return(Union(spaces)); }
private ProgramSet LearnTree(PremSpec <TInput, SyntaxNode> spec) { // Case 1: leaf nodes, using `Leaf`. if (spec.Forall((i, o) => o is Token)) { #if DEBUG Log.Tree("Leaf |- {0}", spec); #endif Label label; if (spec.Identical((i, o) => o.label, out label)) { #if DEBUG Log.IncIndent(); Log.Tree("label = {0}", label); #endif var tokenSpace = Intersect(spec.Select(p => LearnToken(p.Key, p.Value.code))); #if DEBUG Log.DecIndent(); #endif if (!tokenSpace.IsEmpty) { return(ProgramSet.Join(Op(nameof(Semantics.Leaf)), ProgramSet.List(Symbol("label"), Label(label)), tokenSpace)); } } // else: Inconsistent specification. } // Case 2: nodes/lists, copy a reference from old tree. if (spec.Forall((i, o) => o.matches.Any())) { #if DEBUG Log.Tree("Copy |- {0}", spec); Log.IncIndent(); #endif var refSpecs = spec.FlatMap((i, o) => o.matches); var refSpaces = new List <ProgramSet>(); #if DEBUG var total = refSpecs.Count(); var count = 1; #endif foreach (var refSpec in refSpecs) { #if DEBUG Log.Tree("{0}/{1} ref |- {2}", count, total, refSpec); Log.IncIndent(); #endif var space = LearnRef(refSpec); if (!space.IsEmpty) { refSpaces.Add(space); break; } #if DEBUG Log.DecIndent(); count++; #endif } #if DEBUG Log.DecIndent(); #endif var refSpace = Union(refSpaces); if (!refSpace.IsEmpty) { return(ProgramSet.Join(Op(nameof(Semantics.Copy)), refSpace)); } } // Case 3: constructor nodes, using `Node`. if (spec.Forall((i, o) => o is Node)) { var childrenSpace = Optional <ProgramSet> .Nothing; #if DEBUG Log.Tree("Node |- {0}", spec); #endif Label label; if (spec.Identical((i, o) => o.label, out label)) { var labelSpace = ProgramSet.List(Symbol("Label"), Label(label)); var childrenSpec = spec.MapOutputs((i, o) => o.GetChildren()); #if DEBUG Log.IncIndent(); Log.Tree("label = {0}", label); #endif int arity; // Same number of children, learn one-by-one. if (childrenSpec.Identical((i, cs) => cs.Count(), out arity)) { #if DEBUG Log.Tree("children |- {0}", childrenSpec); Log.IncIndent(); #endif childrenSpace = LearnChildren(childrenSpec); #if DEBUG Log.DecIndent(); #endif if (childrenSpace.HasValue && !childrenSpace.Value.IsEmpty) { return(ProgramSet.Join(Op(nameof(Semantics.Node)), ProgramSet.List(Symbol("label"), Label(label)), childrenSpace.Value)); } } else // Different number of children, try `Append`. { #if DEBUG Log.Tree("append |- {0}", childrenSpec); Log.IncIndent(); #endif for (int k = 1; k <= 2; k++) { childrenSpace = LearnAppend(childrenSpec, k); if (childrenSpace.HasValue) { break; } } #if DEBUG Log.DecIndent(); #endif } #if DEBUG Log.DecIndent(); #endif if (childrenSpace.HasValue && !childrenSpace.Value.IsEmpty) { return(ProgramSet.Join(Op(nameof(Semantics.Node)), labelSpace, childrenSpace.Value)); } } } // else: Inconsistent specification. return(ProgramSet.Empty(Symbol("tree"))); }
/// <summary> /// Learning a set of `program`s, i.e. tree transformers, that are consistent with the specification. /// </summary> /// <param name="spec">Specification of the form: input -> new tree.</param> /// <returns>Consistent programs (if exist) or nothing.</returns> private Optional <ProgramSet> LearnProgram(PremSpec <TInput, SyntaxNode> spec) { // Preparation: compute sources. foreach (var input in spec.Keys) { errNodes[input] = input.errNode as Leaf; } foreach (var key in spec.Keys.Select(i => i.Keys).Intersect()) { var varNodes = spec.MapOutputs((i, o) => i.inputTree.Leaves() .Where(l => l.code == i[key] && i[key] != i.errNode.code).ArgMin(l => l.depth)); if (varNodes.Forall((i, v) => v != null)) { varNodeDict[key] = varNodes; } } // Preparation: Before we synthesize `target`, we have to first perform a diff. var diffResults = spec.MapOutputs((i, o) => SyntaxNodeComparer.Diff(i.inputTree, o)); // #if DEBUG // var printer = new IndentPrinter(); // foreach (var p in diffResults) // { // Log.Fine("Diff:"); // p.Value.Value.Item1.PrintTo(printer); // printer.PrintLine("<->"); // p.Value.Value.Item2.PrintTo(printer); // } // #endif // Preparation: Before we synthesize `newTree`, // we have to perform matching between the old tree and the new node. var treeSpec = diffResults.MapOutputs((i, o) => o.Value.Item2); foreach (var p in treeSpec) { var matcher = new SyntaxNodeMatcher(); var matching = matcher.GetMatching(p.Value, p.Key.inputTree); foreach (var match in matching) { match.Key.matches = new List <SyntaxNode>(match.Value); } } // Start synthesis. if (diffResults.Forall((i, o) => o.HasValue)) { // 1. Synthesize param `target`. var targetSpec = diffResults.MapOutputs((i, o) => o.Value.Item1); ProgramSet targetSpace; #if DEBUG Log.Tree("target |- {0}", targetSpec); Log.IncIndent(); #endif // Special case: error node = expected output, use `Err`. if (targetSpec.Forall((i, o) => i.errNode.Equals(o))) { #if DEBUG Log.Tree("Err(old)"); #endif targetSpace = ProgramSet.List(Symbol(nameof(Semantics.Err)), Err()); } // General case: try `ref`. else { targetSpace = LearnRef(targetSpec); } #if DEBUG Log.DecIndent(); #endif if (targetSpace.IsEmpty) { return(Optional <ProgramSet> .Nothing); } // 2. Synthesize param `tree` as the `newTree`, constructed by `New(tree)`. #if DEBUG Log.Tree("tree |- {0}", treeSpec); Log.IncIndent(); #endif var treeSpace = LearnTree(treeSpec); #if DEBUG Log.DecIndent(); #endif if (treeSpace.IsEmpty) { return(Optional <ProgramSet> .Nothing); } // All done, return program set. return(ProgramSet.Join(Op(nameof(Semantics.Transform)), targetSpace, ProgramSet.Join(Op(nameof(Semantics.New)), treeSpace)).Some()); } return(Optional <ProgramSet> .Nothing); }