package edu.neu.ccs.demeterf.demfgen;

import edu.neu.ccs.demeterf.lib.*;
import edu.neu.ccs.demeterf.demfgen.classes.*;
import edu.neu.ccs.demeterf.demfgen.dgp.DGPFunc;
import edu.neu.ccs.demeterf.demfgen.pcdgp.PCDGPFunc;
import edu.neu.ccs.demeterf.demfgen.traversals.Travs;
import edu.neu.ccs.demeterf.dispatch.*;
import edu.neu.ccs.demeterf.*;
import edu.neu.ccs.demeterf.demfgen.ClassGen.ArityPair;
import edu.neu.ccs.demeterf.demfgen.ClassHier.InhrtPair;
import java.io.*;
import edu.neu.ccs.demeterf.util.Util;
import edu.neu.ccs.demeterf.util.CLI;


/** DemFGen Main program/class */
public class DemFGenMain{
    /** Simple (shorter) Print to Std-Error */
    static void p(String s){ if(!Diff.optionSet(Diff.quiet))System.err.print(s); }
    /** Create a String of spaces with the given width */
    static String gap(int len){
       if(len <= 0)return "";
       return " "+gap(len-1);
    }
    /** Quit/Exit due to some error (print before calling) */
    public static void abort(){ System.exit(1); }
    /** Print the DemFGen Header for the given language (e.g., "Java" or "C#") */
    public static void header(String lang){
      p("\n                 \u25e4------------------------------\u25e5"+
        "\n                 |         DemeterF "+lang+gap(12-lang.length())+"|"+
        "\n                 |          "+Diff.buildDate+"          |"+
        "\n                 \u25e3------------------------------\u25e2\n\n");
    }
    static void timing(String what, long start){
        //System.out.println(pad(what+": ",30)+(System.currentTimeMillis()-start));
    }
    /** Main entry point for DemFGen. Parses the CD and BEH files, manages arguments,
     *    and generates classes.  All the real stuff is implemented below, and in separate
     *    classes in the "demeterf.demfgen.*" classes. */
    public static void main(String args[], String lang) throws Exception {
      long time = System.currentTimeMillis();
      List<String>[] all = CLI.splitArgs(args);
      List<String> opts = all[CLI.OPTS];
      Diff.storeOptions(opts);
      String nonOpt[] = all[CLI.ARGS].toArray(new String[all[CLI.ARGS].length()]);
  	
  	  DemFGenMain.header(lang);
  	
      if(Diff.optionSet(Diff.help))usage(true,"");
      if(nonOpt.length != 3)usage(false,"Not enough arguments");
      List<String> unknown = CLI.invalidOptions(opts, Diff.validOptions);
      if(!unknown.isEmpty())usage(false,"Unknown Option(s): "+unknown.toString(", ", ""));
      
      String
          cdFile = nonOpt[0],
          behFile = nonOpt[1],
          outDir = nonOpt[2];
      
      // Trim annoying final separator
      if(outDir.lastIndexOf(File.separatorChar) == outDir.length()-1)
          outDir = outDir.substring(0,outDir.length()-1);
      final String dir = outDir;
      
      try{
          long starter = System.currentTimeMillis();
          final List<CDFile> CDs = resolveCDFile(cdFile);
          final List<BehDef> BEHs = resolveBEHFile(behFile);
          final PackageDef basepkg = CDs.top().getPkg();
          timing("ParseIn",starter);
          boolean parser = !Diff.optionSet(Diff.noparse);
          
          Util.addBuiltIns(DoGen.class/*,Ident.class*/);
          if(!basepkg.hasPkg())
              p("\n !! Warning: No Root Package Specified\n"+
                      "     Parser/DGP classes may not be accessible\n\n");
          
          List<ArityPair> arities = CDs.fold(new List.Fold<CDFile,List<ArityPair>>(){
              public List<ArityPair> fold(CDFile f, List<ArityPair> r){
                  return TypeCheck.defsToList(f.getTypes()).append(r);
              }}, ClassGen.Primitives);
          TypeCheck tc = new TypeCheck();
          Travs.TheFactory.makeTypeCheckTrav(tc).traverse(CDs, new TypeCheck.Env(arities));
          
          if(Diff.optionSet(Diff.showcd))
              p("\n ** Full Class Dictionary:\n     "+Print.PrintM(CDs).replace("\n","\n     "));
          if(Diff.optionSet(Diff.graph)){
              p("\n ** Generating DOT Graph...\n");
              GraphGen.genGraph(CDs, dir);
              System.exit(0);
          }else{
              List<InhrtPair> inhrt = DemFGenMain.subtypes(CDs);
              String dgpMeths = "";
              int dgp = OptStart.index(opts, Diff.dgp+":");
              if(dgp >= 0){
                  p(" ** Loading DGP Functions...\n     [");
                  Type.addPath("edu.neu.ccs.demeterf.demfgen.dgp.");
                  List<DGPFunc> funcs = loadDGP(CLI.separateOption("dgp",opts), new DGPLoad(),"DGP");
                  Type.removePath("edu.neu.ccs.demeterf.demfgen.dgp.");
                  p("]\n ** Generating DGP Functions...\n     [");
                  dgpMeths = funcs.foldl(new List.Fold<DGPFunc, String>(){
                      public String fold(DGPFunc f, String s){
                          return (f.method(basepkg.name())+s);
                      }
                  },"");
                  starter = System.currentTimeMillis();
                  doDGPGen(funcs,CDs,BEHs,dir,inhrt);
                  timing("DGPFuncs",starter);
                  Type.removePath("edu.neu.ccs.demeterf.demfgen.dgp.");
                  p("]\n");
              }

              if(!Diff.optionSet(Diff.nogen)){
                  List<PCDGPFunc> funcs = List.create();
                  if(OptStart.index(opts, Diff.pcdgp+":") >= 0){
                      p(" ** Loading PCDGP Functions...\n     [");
                      Type.addPath("edu.neu.ccs.demeterf.demfgen.pcdgp.");
                      funcs = loadDGP(CLI.separateOption("pcdgp",opts),new PCDGPLoad(),"PCDGP");
                      Type.removePath("edu.neu.ccs.demeterf.demfgen.pcdgp.");
                      p("]\n");
                  }
                  p(" ** Generating Classes...\n");
                  starter = System.currentTimeMillis();
                  ClassGen.genClasses(CDs, BEHs, dir, dgpMeths, opts, inhrt, funcs, basepkg);
                  timing("ClassGen",starter);
              }
              if(parser){
                  p(" ** Generating Parser...\n");
                  ParseGen.genParser(CDs, dir, inhrt, basepkg);
              }
              if(!Diff.optionSet(Diff.nogen)){
                  int lib = OptStart.index(opts, Diff.lib+":");
                  List<String> pkgdirs = CDs.foldr(new List.Fold<CDFile,List<String>>(){
                     public List<String> fold(CDFile cd, List<String> r){
                         return (cd.getTypes().anyGen())?
                                 r.push(DemFGenMain.pkgdir(dir, cd.getPkg(), true)):r;
                     }
                  }, List.<String>create());
                  Make.make(dir, basepkg, parser && !Diff.optionSet(Diff.noparsecc), opts, lib, pkgdirs);
              }
              p(" ** Finished ["+seconds(System.currentTimeMillis()-time)+" sec.]\n");
              timing("Total",time);
              System.exit(0);
          }
      }catch(RE re){ error(re,"Runtime");
      }catch(RTParseException pe){ error(pe,"Parse");
      }catch(java.io.FileNotFoundException fe){ error(fe,"File");
      }catch(RTFileNotFound fe){ error(fe,"File");
      }catch(TE te){ error(te,"Type"); }
      System.exit(1);
    }
    /** Pad the given string out to the give size (on the right) */
    public static String pad(String s, int i){
        if(s.length() >= i)return s;
        return pad(s+" ",i);
    }
    /** Return the number of Seconds from the given Milliseconds */
    public static double seconds(long mil){
        return ((int)(mil/10.0))/100.0;
    }
    /** Does the given argument start with the given option prefix (usually "--")? */
    static class OptStart extends List.Pred<String>{
        String start;
        OptStart(String s){ start = s; }
        public boolean huh(String s){ return s.startsWith(start); }
        static int index(List<String> l, String start){
           return l.index(new OptStart(start));
        }
    }
    /** Print an Error Message (default) */
    static void error(Throwable t, String type){
      p("\n\n !! "+type+" Error:\n"+t.getMessage()+"\n\n");
      //t.printStackTrace();
    }
    
    /****************************************************
     ***   Some of these methods are quite useful...  ***
     ****************************************************/
    
    /** Recursively resolve any included CD files, starting with the given file name. */
    public static List<CDFile> resolveCDFile(String file) throws FileNotFoundException{
        try{
           return resolveCDFile(new FileInputStream(file), file);
        }catch(ParseException pe){
           throw new RTParseException(" ** CD File: \""+file+"\"\n"+pe.getMessage());
        }catch(TokenMgrError te){
           throw new RTParseException(" ** CD File: \""+file+"\"\n"+te.getMessage());
        }
    }
    /** Recursively resolve any included CD files from the given InputStream, starting
     *    with the given file name. The name is kept around for ParseError feedback
     *    to the user. */
    public static List<CDFile> resolveCDFile(InputStream in, String name) throws ParseException{
        CDFile main = CDFile.parse(in);
        List<CDFile> CDs = IncludeCDs.resolveCDs(main.getIncl(),name);
        ImportList imports = IncludeCDs.allImports(CDs.push(main));
        return CDs.push(main.updateImports(imports));
    }
    /** Recursively resolve any included BEH files, starting with the given file name. */
    public static List<BehDef> resolveBEHFile(String file) throws FileNotFoundException{
        try{
           return resolveBEHFile(new FileInputStream(file), file);
        }catch(ParseException pe){
           throw new RTParseException(" ** BEH File: \""+file+"\"\n"+pe.getMessage());
        }catch(TokenMgrError te){
           throw new RTParseException(" ** BEH File: \""+file+"\"\n"+te.getMessage());
        }
    }
    /** Recursively resolve any included BEH files from the given InputStream, starting
     *    with the given file name. The name is kept around for ParseError feedback
     *    to the user. */
    public static List<BehDef> resolveBEHFile(InputStream in, String name) throws ParseException{
        BehFile beh = BehFile.parse(in);
        return beh.getBehs().toList().append(IncludeCDs.resolveBEHs(beh.getIncl(),name));
    }
    
    /** Print the full usage information for DemFGen */
    static void usage(boolean help,String bad){
      p("\n"+
        (help?"":" !! "+bad+"\n\n")+
        " ** Usage: DemFGen [Options] <CD-File> <BEH-File> <Output-Dir>\n"+
        (!help?" ** Use --help for a full description\n":
        " The order/placement of options doesn\'t matter, but the relative\n"+
        "    order of the manditory ones must be as shown.\n\n"+
        " CD-File contains the CD to be generated,\n"+
        " BEH-File contains the behavior to be used with classes,\n"+
        " Output-Dir is the directory to place generated files\n\n"+
        " Options can be: \n"+
        //12345678901234567890123456789012345678901234567890123456789012345678901234567890
        "   --help            : Print this usage information.\n"+
        "   --build           : "+Diff.d.makeInfo+"\n"+
        "   --lib:FILE        : Implies --build, Create a library named FILE from the\n"+
        "                         compiled/generated code (JAR for Java, DLL for C#)\n"+
        "   --windows         : Use Windows based command launches and CSC to compile\n"+
        "                         C# instead of GMCS. System PATH and CLASSPATH\n"+
        "                         variables need to be set correctly. Works with both\n"+
        "                         '--build' and '--lib'\n"+
        "   --noshell         : Use Java to run JavaCC, instead of trying to run commands\n"+
        "                         through BASH or Windows CMD\n"+
        "   --nogen           : Don\'t generate the classes... just DGP and Parser\n"+
        "   --noparse         : Don\'t generate the parser files or methods\n"+
        "   --noequals        : Don\'t generate the equals() methods\n"+
        "   --mutable         : Generate 'mutable' fields... not final/readonly\n"+
        "   --graph           : Just print a Dot file to StdOut\n"+
        "   --show            : Print the final deep parsed CD(s)\n"+
        "   --dgp:C1:...:Cn   : A Colon seperated List of Data-generic function\n"+
        "                         classes to be run/generated. Each class must be a\n"+
        "                         subclass of ...demeterf.demfgen.dgp.DGPFunc\n"+
        "                         and accessible in the current classpath.\n"+
        "       * Predefined classes are:\n"+
        "         - Objects to Strings, Each one can be used as a \"toString\" method\n"+
        "           by using the _ToString version\n"+
        "              Print, PrintToString         : in complete CD syntax\n"+
  	    "              PrintHeap, PrintHeapToString : Uses very little Java stack\n"+
  	    "                                             Same method Names as above\n"+
        "              PrintIter                    : Use iteration when possible\n"+
        "              Display, DisplayToString     : nested field/type information\n"+
        "              ToStr, ToString              : simple nested constructors\n"+
        "              ToXML                        : simple XML output\n"+
        "         - Useful methods\n"+
        "              HashCode                     : add deep hashcode methods\n"+        
        "         - Static Code Generation:\n"+
        "              StaticTrav     : Create Static Traversal Class/Methods\n"+
        "                 use --nocontrol to eliminate Traversal control overhead\n"+
        "              StaticTravCtx  : Static Traversal with a context/argument\n"+
        "              StaticTP       : Create a static TP Class for the CD\n"+
        "              StaticTU       : Create a static TU Class for the CD\n"+
        "       * See the demfgen.dgp package source for more details.\n\n"+
        "   --pcdgp:C1:...:Cn : A Colon seperated List of Per-Class Data-generic function\n"+
        "                         classes to be run on each TypeDef. Classes must be a\n"+
        "                         subclass of ...demeterf.demfgen.pcdgp.PCDGPFunc\n"+
        "                         and accessible in the current classpath.\n"+
        "       * Predefined classes are:\n"+
        "         - Getters  : Add getters for all fields. For 'field' the getter is\n"+
        "                        created as 'getField()'.\n"+
        "         - Updaters : Adds an Update method for each field that returns an\n"+
        "                        updated instance; all other fields are the same, but\n"+
        "                        the selected field is replaced.\n"+
        "         - Creator  : Addes a static Creator method that mimics the constructor.\n"+
        "         - Setters  : Add setters for all fields.  ** The '--mutable' option\n"+
        "                        must be used in order for this to work.  Otherwise, try\n"+
        "                        using the Updaters instead.\n"+
        "       * See the demfgen.pcdgp package source for more details.\n")+
        "\n");
      System.exit(1);
    }
    
    /** Load/Instantiation Exception */
    static class LoadException extends RuntimeException{
        public LoadException(String s){ super(s); }
        public LoadException(Throwable e){ super(e); }
    }
    /** Load a specific instance of the given class, and check/cast if needed */
    static abstract class Loader<X> extends List.Map<String, X>{
        public X map(String n){
            try{Class<?> c = Type.classForName(n); return instance(c);
            }catch(Exception e){throw new RuntimeException(e); }
        }
        abstract X instance(Class<?> c) throws Exception;
    }
    static class DGPLoad extends Loader<DGPFunc>{
        DGPFunc instance(Class<?> c) throws Exception{
            if(DGPFunc.class.isAssignableFrom(c)){
                p(""+c.getSimpleName()+", ");
                return (DGPFunc)(c.newInstance());
            }
            throw new LoadException("Unknown DGPFunc");
        }
    }
    static class PCDGPLoad extends Loader<PCDGPFunc>{
        PCDGPFunc instance(Class<?> c) throws Exception{
            if(PCDGPFunc.class.isAssignableFrom(c)){
                p(""+c.getSimpleName()+", ");
                java.lang.reflect.Constructor<?> constr = c.getConstructor(new Class[]{List.class});
                return (PCDGPFunc)(constr.newInstance(new Object[]{List.<String>create()}));
            }
            throw new LoadException("Unknown PCDGPFunc");
        }
    }
    /** Lookup the given DGP function classes */
    static <X> List<X> loadDGP(String names[], final Loader<X> load, final String typ){
       return List.create(names).reverse().map(new List.Map<String, X>(){
           public X map(String name){
               try{ return load.map(name);
               }catch(TypeSearchException e)
               { p("\n !! DGP Error: Couldn\'t Find function class: \'"+name+"\'\n\n"); }
               catch(LoadException e)
               { p("\n !! DGP Error: Class \'"+name+"\' isn\'t a subclass of "+typ+"Func\n\n");
               }catch(Exception e)
               { p("\n !! DGP Error: Couldn\'t create function: \'"+name+"\'\n\n"); }
               abort();
               return null;
           }
       });
    }
    
    /** When traversing just return a list of TypeDefs */
    static class JustTypes extends TU<List<TypeDef>>{
      public List<TypeDef> combine(){ return List.create(); }
      public List<TypeDef> fold(List<TypeDef> a, List<TypeDef> b){ return a.append(b); }
      List<TypeDef> combine(TypeDef t){ return combine().push(t); }
    }
    /** Get just the TypeDefs from a List of DemFGenMains */
    public static List<TypeDef> justTypes(List<CDFile> CD){
        List<TypeDef> types = new JustTypes().traverse(CD);
        return types;
    }
    /** Flatten the classes so that fields are represented in all concrete
     *    classes (i.e., push common fields down to subtypes) */
    public static List<TypeDef> flatten(List<CDFile> CD, final List<InhrtPair> inhrt){
        List<TypeDef> types = new Traversal(new ID(){
            TypeDef combine(TypeDef td){ return td; }
            ClassDef combine(ClassDef cd, DoGen g, ident n, TypeDefParams ps, PESubtypeList sts, FieldList fs, Impl i){
                return new ClassDef(g,n,ps,sts,
                        fs.append(ClassHier.superFieldsAndSyntax(ps.toList(), inhrt, ""+n)
                                .foldr(new List.Fold<FieldOrSyntax, FieldList>(){
                                    public FieldList fold(FieldOrSyntax f, FieldList r){ return r.push(f); }
                                }, new FieldEmpty())), i);    
            }
            Empty<TypeDef> combine(Empty<TypeDef> e){ return e; }
            List<TypeDef> combine(List<TypeDef> l, TypeDef f, List<TypeDef> r){ return r.push(f); }
        },Control.bypass(ClassDef.class,IntfcDef.class)).traverse(justTypes(CD));
        return types;
    }
    /** Remove all the syntax froma given CD */
    public static List<TypeDef> removeSyntax(List<TypeDef> types){
        return Factory.newTraversal(new TP(){
            FieldList combine(FieldList l, Syntax s, FieldList r){ return r; }
        },Control.builtins(Syntax.class)).traverseList_TypeDef_(types);
    }
    /** DGP generation function class */
    public static class DGPGen extends FC{
        final List<TypeDef> types;
        final List<BehDef> BEHs;
        final String dir, imports, suff;
        final PackageDef pkg;
        
        public DGPGen(List<CDFile> CD, List<BehDef> Bs, String d, List<InhrtPair> inhrt){
            types = flatten(CD, inhrt);
            BEHs = Bs;
            imports = ""+IncludeCDs.allImports(CD);
            pkg = CD.top().getPkg();
            suff = CD.top().getPkg().hasPkg()?Diff.d.classEnd:"";
            dir = DemFGenMain.pkgdir(d, pkg, true);
        }
        public String combine(List<DGPFunc> e, String f, String r){ return f+r; }
        public String combine(Empty<DGPFunc> e){ return ""; }
        
        public String combine(DGPFunc f){
            long starter = System.currentTimeMillis();
            String name = f.fileName();
            String extra = behBody(BEHs, name);
            DGPFunc.Trav trav = f.traversalObj(extra);
            String ret = trav.traverseOption_List_TypeDef__(Option.some(types));
            // Removed to support inlined DGP traversals
            //   DFGTrav trav = Factory.newTraversal(f.functionObj(extra), f.control());
            //   String ret = trav.<String>traverseOption_List_TypeDef__(Option.some(types));
            
            // Make sure the package dir exists if needed
            Util.writeFile(name, "."+f.fileSuffix(), ret+suff+"\n", dir,
                    f.header(Preamble.header,pkg,imports));
            timing("    DGP-"+name+": ",starter);
            return (""+name+", ");
        }
    }
    
    /** Calculate the directory for the package based on command line args  */
    public static String pkgdir(String dir, PackageDef pkg, boolean create){
        if(pkg.hasPkg() && !Diff.optionSet(Diff.flatdirs)){
            String d = dir+File.separator+pkg.dir();
            // Make sure it exists...
            if(create)Util.createWritableDir(d);
            return d;
        }
        return dir;
    }
    
    /** Run each of the DGP function classes and allow them to create files */
    static void doDGPGen(List<DGPFunc> funcs, List<CDFile> CDs, List<BehDef> BEHs, String dir, List<InhrtPair> inhrt){
        DGPGen gen = new DGPGen(CDs,BEHs,dir,inhrt);
        String names = Travs.TheFactory.makeDGPGenTrav(gen).traverse(funcs);
        p(names);
    }
    
    /** Find BEH attached to a giv en Name */
    static class FindBeh extends List.Pred<BehDef>{
        String name;
        FindBeh(String n){ name = n; }
        public boolean huh(BehDef b){ return name.equals(""+b.getName()); }
    }
    /** Find the BEH body for the given class/interface */
    public static String behBody(List<BehDef> behs, String c){
        List<BehDef> match = behs.filter(new FindBeh(c));
        return match.fold(new List.Fold<BehDef, String>(){
            public String fold(BehDef b, String r){
                return b.getBody().getText()+r;
            }
        },"");
    }
    
    /** Instantiate a type definition with the given environment */
    private static TypeDef instantiate(TypeDef td, List<StrLTrip.StrPair> env){
        return new Traversal(new Subst()).<TypeDef>traverse(td,env);
    }
    /** Type instantiation Function Class */
    public static List<FieldOrSyntax> instantiate(List<FieldOrSyntax> fs, List<String> bnds, List<String> uses){
        List<StrLTrip.StrPair> env = bnds.zip(new List.Zip<String,String,StrLTrip.StrPair>(){
            public StrLTrip.StrPair zip(String b, String u){ return new StrLTrip.StrPair(b,u); }
        }, uses);
        return new Traversal(new Subst()).<List<FieldOrSyntax>>traverse(fs,env);
    }
    /** Instantiate a generic type definition.  Basically replace all occurences of the
     *    TypeParameters using the environment implied by the given TypeUse */
    public static TypeDef instantiate(TypeUse tu, List<TypeDef> aT){
        TypeDef def = aT.find(new FindType(""+tu.getName()));
        String 
            dpar[] = def.typeParams().toArray(),
            upar[] = tu.getTparams().toArray();
        if(dpar.length != upar.length){
            throw new RuntimeException("Wrong number of Type parameters for "+
                    def.name()+def.typeParams().print()+"\n  - Given "+upar.length+" in "+tu.print()+"!"+
                    "\n Use: "+tu.print()+
                    "\n Def: "+def.print()+"\n");
        }
        List<StrLTrip.StrPair> env = makeEnv(dpar,upar,0);
        return instantiate(def,env);
    }
    /**  Predicate to search for a type definition by String name */
    static class FindType extends List.Pred<TypeDef>{
        String name;
        FindType(String n){ name = n; }
        public boolean huh(TypeDef t){ return name.equals(""+t.name()); }
        public String toString(){ return "typedef["+name+"]"; }
    }
    /** Find a type by Ident name */
    static class FIdent extends List.Pred<StrLTrip.StrPair>{
        String name;
        FIdent(ident look){ name = ""+look; }
        public boolean huh(StrLTrip.StrPair t){ return name.equals(t.n);}
    }
    /** Substitution class, replaces TypeUses and DefParams using the given 
     *    Environment context */
    public static class Subst extends StaticTP{
        String lookup(ident name, List<StrLTrip.StrPair> env){
            FIdent find = new FIdent(name);
            if(env.contains(find))
                return env.find(find).b;
            return name.toString();
        }
        TypeUse combine(TypeUse t, ident name, EmptyUseParams ps, List<StrLTrip.StrPair> env){
            return TypeUse.makeType(lookup(name,env));
        }
        NameDef combine(NameDef d, ident i, Bound b, List<StrLTrip.StrPair> env){
            return new NameDef(new ident(ClassGen.unlocal(lookup(i,env))), b);
        }
    }
    /** Create an environment from definition variables and actual uses */
    public static List<StrLTrip.StrPair> makeEnv(String[] d, String[] u, int i){
        if(i == d.length)return List.<StrLTrip.StrPair>create();
        return makeEnv(d,u,i+1).push(new StrLTrip.StrPair(d[i],u[i]));
    }
    
    /** Return a list of all the suptypes from the given CDFiles... */
    public static List<ClassHier.InhrtPair> subtypes(List<CDFile> CD){
        return CD.fold(new List.Fold<CDFile,List<ClassHier.InhrtPair>>(){
            public List<ClassHier.InhrtPair> fold(CDFile f, List<ClassHier.InhrtPair> r){
                return CollectInherit.inheritPairs(f.getTypes()).append(r);
            } }, List.<ClassHier.InhrtPair>create());
    }
}