nitg: Corrected bug when creating a new AVarExpr, uses the last inferred type instead...

[nit.git] / src / typing.nit

diff --git a/src/typing.nit b/src/typing.nit
index 57e4b6d..c760c74 100644 (file)
--- a/src/typing.nit
+++ b/src/typing.nit
@@ -501,12 +501,6 @@ redef class AConcreteMethPropdef
                        assert variable != null
                        variable.declared_type = mtype
                end
-               for i in [0..mmethoddef.msignature.mclosures.length[ do
-                       var mclosure = mmethoddef.msignature.mclosures[i]
-                       var variable = self.n_signature.n_closure_decls[i].variable
-                       assert variable != null
-                       variable.declared_type = mclosure.mtype
-               end
                v.visit_stmt(nblock)
 
                if not nblock.after_flow_context.is_unreachable and mmethoddef.msignature.return_mtype != null then
@@ -702,6 +696,8 @@ redef class AVarReassignExpr
                var readtype = v.get_variable(self, variable)
                if readtype == null then return
 
+               read_type = readtype
+
                var writetype = variable.declared_type
                if writetype == null then return
 
@@ -1006,21 +1002,16 @@ redef class AOrElseExpr
 
                var t = v.merge_types(self, [t1, t2])
                if t == null then
-                       v.error(self, "Type Error: ambiguous type {t1} vs {t2}")
+                       t = v.mmodule.object_type
+                       if t2 isa MNullableType then
+                               t = t.as_nullable
+                       end
+                       #v.error(self, "Type Error: ambiguous type {t1} vs {t2}")
                end
                self.mtype = t
        end
 end
 
-redef class AEeExpr
-       redef fun accept_typing(v)
-       do
-               v.visit_expr(n_expr)
-               v.visit_expr(n_expr2)
-               self.mtype = v.type_bool(self)
-       end
-end
-
 redef class ATrueExpr
        redef fun accept_typing(v)
        do
@@ -1239,14 +1230,6 @@ redef class ASendExpr
                else
                        self.is_typed = true
                end
-
-               if self.n_closure_defs.length == msignature.mclosures.length then
-                       for i in [0..self.n_closure_defs.length[ do
-                               self.n_closure_defs[i].accept_typing(v, msignature.mclosures[i])
-                       end
-               else
-                       debug("closure: got {self.n_closure_defs.length}, want {msignature.mclosures.length}")
-               end
        end
 
        # The name of the property
@@ -1545,6 +1528,14 @@ redef class ANewExpr
                                v.error(self, "Type error: cannot instantiate the formal type {recvtype}.")
                                return
                        end
+               else
+                       if recvtype.mclass.kind == abstract_kind then
+                               v.error(self, "Cannot instantiate abstract class {recvtype}.")
+                               return
+                       else if recvtype.mclass.kind == interface_kind then
+                               v.error(self, "Cannot instantiate interface {recvtype}.")
+                               return
+                       end
                end
 
                var name: String
@@ -1658,50 +1649,6 @@ end
 
 ###
 
-redef class AClosureCallExpr
-       redef fun accept_typing(v)
-       do
-               var variable = self.variable
-               if variable == null then return # Skip error
-
-               var recvtype = v.nclassdef.mclassdef.bound_mtype
-               var msignature = variable.declared_type.as(not null)
-               msignature = v.resolve_for(msignature, recvtype, false).as(MSignature)
-
-               var args = n_args.to_a
-               v.check_signature(self, args, variable.name, msignature)
-
-               self.is_typed = true
-               self.mtype = msignature.return_mtype
-       end
-end
-
-redef class AClosureDef
-       var mclosure: nullable MParameter
-
-       private fun accept_typing(v: TypeVisitor, mparameter: MParameter)
-       do
-               var variables = self.variables
-               if variables == null then return
-
-               self.mclosure = mparameter
-               var msignature = mparameter.mtype.as(MSignature)
-
-               if msignature.arity != variables.length then
-                       v.error(self, "Type error: closure {mparameter.name} expects {msignature.arity} parameters, {variables.length} given")
-                       return
-               end
-
-               for i in [0..variables.length[ do
-                       variables[i].declared_type = msignature.mparameters[i].mtype
-               end
-
-               v.visit_stmt(self.n_expr)
-       end
-end
-
-###
-
 redef class ADebugTypeExpr
        redef fun accept_typing(v)
        do