!7

srecord DollarVarPattern(S pat) {}
srecord Definition(O lhs, O rhs) {}
srecord PatternMatches(O pat, O s) {}
srecord Input(S s) {}

sS defs = [[
A cup of water = A cup with water inside
A cup of Peter = A cup that belongs to Peter
A cup of glass = A cup that consists of glass
A cup of style = A cup that has a lot of style
]];

static new LinkedHashSet objects;

p-exp {
  objects.add(Input("a cup of joe"));
  
  for (S s : tlft(defs)) {
    L<S> l = splitAtJavaToken(s, "=");
    objects.add(Definition(first(l), second(l)));
  }
  
  int initialObjects = l(objects);
  long startTime = now();
  int n = -1;
  while (l(objects) > n) {
    n = l(objects);
    L<Definition> defs = instancesOf(Definition, objects);
    for (Definition a : defs)
      for (Definition b : defs)
        if (a.lhs instanceof S && b.lhs instanceof S) {
          S pat = combineToDollarVarPattern((S) a.lhs, (S) b.lhs);
          if (containsDollarVars(pat))
            objects.add(DollarVarPattern(pat));
        }
        
    for (DollarVarPattern pat : instancesOf(DollarVarPattern, objects)) {
      for (Definition a : defs) if (a.lhs instanceof S) {
        SS match = matchDollarVarsIC(pat.pat, (S) a.lhs);
        if (match != null)
          generalizeDefinition(a, match);
      }
    }
    
    for (Input i : instancesOf(Input, objects))
      for (Definition a : defs) if (a.lhs instanceof DollarVarPattern) {
        SS match = matchDollarVarsIC(((DollarVarPattern) a.lhs).pat, i.s);
        if (match != null)
          specializeDefinition(a, match);
      }
  }
  long time = now()-startTime;
  
  pnlStruct(objects);
  print("\n" + n2(l(objects)-initialObjects, "rewrite") + " in " + (now()-startTime) + " ms");
  
  final Input in = firstInstanceOf(Input, objects);
  if (in != null) {
    L<Definition> definitions = [Definition d : instancesOf(Definition, objects) | eqic_gen(d.lhs, in.s)];
    print("Got " + n2(definitions, "definition") + " for input " + quote(in.s) + (empty(definitions) ? "." : ":"));
    printStructLinesIndent(definitions);
    assertEquals(4, l(definitions));
  }
}

svoid generalizeDefinition(Definition def, SS match) {
  SS rev = reverseCIMap(match);
  S lhs = transformEachTokenUsingMap((S) def.lhs, rev);
  S rhs = transformEachTokenUsingMap((S) def.rhs, rev);
  addIfNotNull(objects, Definition(DollarVarPattern(lhs), DollarVarPattern(rhs)));
}

svoid specializeDefinition(Definition def, SS match) {
  S lhs = transformEachTokenUsingMap(((DollarVarPattern) def.lhs).pat, match);
  S rhs = transformEachTokenUsingMap(((DollarVarPattern) def.rhs).pat, match);
  addIfNotNull(objects, Definition(lhs, rhs));
}