Add Lambda Expression to parser and Type. Add eraseF function

src/main/scala/hb/dhbw/AST.scala

@@ -14,6 +14,7 @@ final case class FieldVar(e: Expr, f: String) extends Expr
 final case class MethodCall(e: Expr, name: String, params: List[Expr]) extends Expr
 final case class Constructor(className: String, params: List[Expr]) extends Expr
 final case class Cast(to: Type, expr: Expr) extends Expr
+final case class Lambda(p: String, expr: Expr) extends Expr
 
 object ASTBuilder {
   def fromParseTree(toAst: List[ParserClass]) = new ASTBuilderMonad().fromParseTree(toAst)
@@ -37,6 +38,7 @@ object ASTBuilder {
       case PFieldVar(e, f) => FieldVar(fromParseExpr(e, genericNames), f)
       case PCast(ntype, e) => Cast(nTypeToType(ntype, genericNames), fromParseExpr(e, genericNames))
       case PLocalVar(n) => LocalVar(n)
+      case PLambda(p, e) => Lambda(p, fromParseExpr(e, genericNames))
     }
 
     private def freshTPV() = {

src/main/scala/hb/dhbw/EqSet.scala

@@ -1,8 +0,0 @@
-package hb.dhbw
-
-class EqSet {
-
-  def addAndConstraint(cons: Set[Constraint]) {}
-
-}
-

src/main/scala/hb/dhbw/FJTypeinference.scala

@@ -41,26 +41,23 @@ object FJTypeinference {
   ).map(it => (convertRefType(it._1), convertRefType(it._2))).toSet)
   private def cToUnifyType(c: Class): UnifyRefType = UnifyRefType(c.name, c.genericParams.map(it => convertType(it._1)))
 
+  /*
+  Die generics sind für alle Methoden die gleichen. Falls dies der Fall ist, kann man einfach nach Sub typen in den Parametern und return-Typ filtern
+   */
   private def removeOverloadedSubtypeMethods(in: Class, finiteClosure: FiniteClosure) = {
     def convertToFJType(in: Type): FJNamedType = in match {
       case GenericType(name) => FJNamedType(name, List())
       case RefType(n, p) => FJNamedType(n,p.map(convertToFJType))
     }
     def methodIsSupertype(m : Method, superMethod: Method) = {
-      def getBound(t: Type): Type = t match {
-        case GenericType(x) =>
-          (in.genericParams ++ m.genericParams.map(c => (c.asInstanceOf[LessDot].l, c.asInstanceOf[LessDot].r)))
-          .find(p => p._1.equals(GenericType(x))).map(_._2).map(getBound).get
-        case x => x
-      }
-      if(m.params.size != superMethod.params.size){
-        false
-      }else{
-        val returnIsSub = finiteClosure.aIsSubtypeOfb(convertToFJType(getBound(m.retType)), convertToFJType(getBound(superMethod.retType)))
+      if(m.genericParams.equals(superMethod.genericParams)) {
+        val returnIsSub = finiteClosure.aIsSubtypeOfb(convertToFJType(m.retType), convertToFJType(superMethod.retType))
         val paramsAreSup = m.params.zip(superMethod.params).foldLeft(true)((isSub, m2) => {
-          isSub && finiteClosure.aIsSubtypeOfb(convertToFJType(getBound(m2._2._1)), convertToFJType(getBound(m2._1._1)))
+          isSub && finiteClosure.aIsSubtypeOfb(convertToFJType(m2._2._1), convertToFJType(m2._1._1))
         })
         returnIsSub && paramsAreSup
+      }else{
+        false
       }
     }
 
@@ -78,23 +75,19 @@ object FJTypeinference {
     Class(in.name, in.genericParams, in.superType, in.fields, newMethods.toList)
   }
 
-  def sigmaReplace(sigma:Map[String, Type], unifyType: UnifyType): Type = unifyType match {
-    case UnifyRefType(n, ps) => RefType(n, ps.map(it => sigmaReplace(sigma, it)))
-    case UnifyTV(a) => sigma(a)
-  }
-
   def typeinference(str: String): Either[String, List[Class]] = {
     val ast = Parser.parse(str).map(ASTBuilder.fromParseTree(_))
     var typedClasses: List[Class] = List()
     ast.map(ast => {
       ast.foldLeft(List[Class]())((cOld, c) => {
         val newClassList = cOld :+ c
-        val typeResult = TYPE.generateConstraints(newClassList, generateFC(newClassList))
+        val fc = generateFC(newClassList)
+        val typeResult = TYPE.generateConstraints(newClassList, fc)
         val unifyResult = Unify.unifyIterative(convertOrConstraints(typeResult._1), typeResult._2)
 
         //Insert intersection types
         //val typeInsertedC = InsertTypes.applyResult(sigma, generics, c)//InsertTypes.insert(unifyResult, c)
-        val typeInsertedC = InsertTypes.applyUnifyResult(unifyResult, c)
+        val typeInsertedC = removeOverloadedSubtypeMethods(InsertTypes.applyUnifyResult(unifyResult, c), fc)
         typedClasses = typedClasses :+ typeInsertedC
         cOld :+ typeInsertedC
       })

src/main/scala/hb/dhbw/InsertTypes.scala

@@ -108,22 +108,6 @@ object InsertTypes {
 
     val constraints = flatted.map(_.map(refTypeInConsToGenerics(_)))
 
-    /*
-
-    def extractTVNames(unifyType: UnifyType): Set[String] = unifyType match {
-      case UnifyTV(name) => Set(name)
-      case UnifyRefType(_, params) => params.flatMap(extractTVNames(_)).toSet
-    }
-
-    val genericNames:Set[String] = into.genericParams.map(_._1).flatMap(_ match {
-      case GenericType(name) => Some(name)
-      case _ => None
-    }).toSet ++ unifyResult.flatMap(_.flatMap(_ match{
-      case UnifyLessDot(a,b) => Set(a, b)
-      case UnifyEqualsDot(a,b) => Set(a,b)
-    })).flatMap(extractTVNames(_))
-    val constraints = normalized.map(_.map(replaceRefTypeWithGeneric(_, genericNames)))
- */
     val newMethods = into.methods.flatMap(m => constraints.map(cons => insert(cons, m)))
     Class(into.name, into.genericParams, into.superType, into.fields, newMethods)
   }

src/main/scala/hb/dhbw/Main.scala

@@ -53,6 +53,7 @@ object Main {
       case FieldVar(e, f) => prettyPrintExpr(e)+"."+f
       case MethodCall(e, name, params) => prettyPrintExpr(e)+"."+name+"("+params.map(prettyPrintExpr(_)).mkString(", ")+")"
       case Constructor(className, params) => "new "+className+"(" + params.map(prettyPrintExpr(_)).mkString(", ") +")"
+      case Lambda(a, expr) => "(" + a + ") -> " + prettyPrintExpr(expr)
     }
     def prettyPrintType(l: Type): String = l match {
       case RefType(name, List()) => name

src/main/scala/hb/dhbw/Parser.scala

@@ -12,6 +12,7 @@ final case class PFieldVar(e: ParserExpr, f: String) extends ParserExpr
 final case class PMethodCall(e: ParserExpr, name: String, params: List[ParserExpr]) extends ParserExpr
 final case class PConstructor(className: String, params: List[ParserExpr]) extends ParserExpr
 final case class PCast(to: NType, expr: ParserExpr) extends ParserExpr
+final case class PLambda(param: String, expr: ParserExpr) extends ParserExpr
 
 final case class NType(name: String, params: List[NType])
 
@@ -35,7 +36,7 @@ object Parser {
     .map(ite => ite._2.map(params => params._1 :: params._2).getOrElse(List.empty))
   def variable[_: P]: P[ParserExpr] = P(ident).map(PLocalVar)
   def cast[_: P]: P[ParserExpr] = P("(" ~ typeParser ~ ")" ~ expr).map(x => PCast(x._1, x._2))
-  def expr[_: P]: P[ParserExpr] = P( (variable | constructor | cast)~ (prefixMethodCall | fieldVar).rep.map(_.toList) )
+  def expr[_: P]: P[ParserExpr] = P( (variable | lambdaExpr | constructor | cast)~ (prefixMethodCall | fieldVar).rep.map(_.toList) )
     .map(ite => ite._2.foldLeft(ite._1) { (e1 : ParserExpr, e2 : ParserExpr) =>
       e2 match{
         case PMethodCall(_, name, e3) => PMethodCall(e1, name, e3)
@@ -43,6 +44,8 @@ object Parser {
       }
     })
 
+  def lambdaExpr[_: P]: P[PLambda] = P( "(" ~ ident ~ ")" ~ "->" ~ expr).map(it => PLambda(it._1, it._2))
+
   def constructor[_: P]: P[ParserExpr] = P( kw("new") ~ methodCall).map(m => PConstructor(m.name,m.params))
 
   def classDefinition[_: P]: P[ParserClass] = P(kw("class") ~ ident ~ genericParamList.? ~ kw("extends") ~ typeParser ~ "{" ~ field.rep(0) ~ method.rep(0) ~ "}")

src/main/scala/hb/dhbw/TYPE.scala

@@ -94,6 +94,14 @@ object TYPE {
         val (rty, cons) = TYPEExpr(expr, localVars, ast)
         (casttype, cons)
       }
+      case Lambda(p, expr) => {
+        val t = freshTPV()
+        val a = freshTPV()
+        val b = freshTPV()
+        val typeRet = TYPEExpr(expr, (t, p) :: localVars, ast)
+        val cons = typeRet._2 ++ List(LessDot(t, a), LessDot(typeRet._1, b))
+        (RefType("Function", List(a, b)), cons)
+      }
     }
 
     private def findMethods(m: String, numParams: Int, ast: List[Class]) =

src/main/scala/hb/dhbw/Unify.scala

@@ -9,17 +9,6 @@ sealed abstract class UnifyType
 final case class UnifyRefType(name: String, params: List[UnifyType]) extends UnifyType
 final case class UnifyTV(name: String) extends UnifyType
 
-/*
-sealed abstract class ResultType
-final case class ResultTV(name: String) extends ResultType
-final case class ResultRefType(name: String, params: List[ResultType]) extends ResultType
-sealed abstract class UnifyResultConstraint
-final case class AExtendsB(a: TypeVariable, b: TypeVariable) extends UnifyResultConstraint
-final case class AExtendsN(a: TypeVariable, n: ResultRefType) extends UnifyResultConstraint
-final case class AEqualsB(a: TypeVariable, b: TypeVariable) extends UnifyResultConstraint
-final case class AEqualsN(a: TypeVariable, n: ResultRefType) extends UnifyResultConstraint
-*/
-
 object Unify {
 
   sealed trait Step4Result{
@@ -43,13 +32,6 @@ object Unify {
     })
     ret = ret.filter(it => !alessdotb.contains(it))
     alessdotb.foreach(it => ret = subst(it.left.asInstanceOf[UnifyTV], it.right, ret))
-    /*
-    .filter(_ match{
-      case UnifyEqualsDot(UnifyTV(a), UnifyTV(b)) => a != b
-      case UnifyLessDot(UnifyTV(_), UnifyTV(_)) => false
-      case _ => true
-    })
-     */
     ret ++ alessdotb.map(_ match {case UnifyLessDot(a, b) => UnifyEqualsDot(a,b)})
   }
 
@@ -80,25 +62,6 @@ object Unify {
     results
   }
 
-  /*
-  def unify(orCons: Set[Set[Set[UnifyConstraint]]], fc: FiniteClosure) : Set[Set[UnifyConstraint]] = {
-    val eqSets = cartesianProduct(orCons)
-    val step2Results = eqSets.flatMap(eqSet => {
-      val rulesResult = applyRules(fc)(eqSet.flatten)
-      step2(rulesResult, fc)
-    })
-    step2Results.flatMap(eqSet => {
-      val (substResult, unifier) = substStep(eqSet)
-      if(!unifier.isDefined){
-        if(isSolvedForm(substResult))
-          Set(substResult)
-        else Set()
-      }else{
-        unify(Set(Set(substResult)), fc).map(s => s + unifier.get)
-      }
-    })
-  }
-*/
   def step2(eq : Set[UnifyConstraint], fc: FiniteClosure) ={
     val eq1 = eq.filter(c => c match{
       case UnifyLessDot(UnifyTV(_), UnifyTV(_)) => true
@@ -169,6 +132,11 @@ object Unify {
     )
   }
 
+  def eraseFRule(eq: Set[UnifyConstraint]): Set[UnifyConstraint]= eq.filter(_ match {
+    case UnifyLessDot(UnifyRefType("Function", _), UnifyRefType("Object", _)) => false
+    case _ => true
+  })
+
   def reduceRule(eq: Set[UnifyConstraint]) =  eq.flatMap(c => c match {
     case UnifyEqualsDot(UnifyRefType(an, ap), UnifyRefType(bn, bp)) => {
       if(an.equals(bn)){
@@ -355,7 +323,7 @@ object Unify {
     var eqFinish: Set[UnifyConstraint] = eq
     do{
       eqNew = doWhileSome(Unify.equalsRule,eqFinish) //We have to apply equals rule first, to get rid of circles
-      eqFinish = eraseRule(swapRule(reduceRule(matchRule(adoptRule(adaptRule(eqNew, fc), fc), fc))))
+      eqFinish = eraseRule(swapRule(reduceRule(eraseFRule(matchRule(adoptRule(adaptRule(eqNew, fc), fc), fc)))))
     }while(!eqNew.equals(eqFinish))
     eqNew
   }

src/test/scala/IntegrationTest.scala

@@ -22,7 +22,12 @@ class IntegrationTest extends FunSuite {
 
   test("ListAddDefinition"){
     val result = FJTypeinference.typeinference("class List<A extends Object> extends Object{\n  add(a){\n  return this;\n}\n}")
-    println(result)
+    println(result.map(Main.prettyPrintAST(_)))
+  }
+
+  test("lambdaIdentity"){
+    val result = FJTypeinference.typeinference("class Test extends Object{\ntest(){\nreturn (a) -> a;\n}\n}")
+    println(result.map(Main.prettyPrintAST(_)))
   }
   /*
   test("PaperExample"){