[svn] r7732: nemerle/trunk/ncc: testsuite/negative/operators.n typing/OverloadPossibility.n typing/Typer-D...

[divan]

Log:
Work on delayed operators (fix part of bug 882).

Author: divan
Date: Wed Jul  4 20:53:39 2007
New Revision: 7732

Modified:
   nemerle/trunk/ncc/testsuite/negative/operators.n
   nemerle/trunk/ncc/typing/OverloadPossibility.n
   nemerle/trunk/ncc/typing/Typer-DelayedTyping.n

Modified: nemerle/trunk/ncc/testsuite/negative/operators.n
==============================================================================
--- nemerle/trunk/ncc/testsuite/negative/operators.n	(original)
+++ nemerle/trunk/ncc/testsuite/negative/operators.n	Wed Jul  4 20:53:39 2007
@@ -40,7 +40,7 @@
           {
                   mutable  k =  Foo ();
 
-                  mutable  i = ~ k; (); // E: cannot find the operator
+                  mutable  i = ~ k; (); // E: typing fails on finding the operator
 
           }
   }

Modified: nemerle/trunk/ncc/typing/OverloadPossibility.n
==============================================================================
--- nemerle/trunk/ncc/typing/OverloadPossibility.n	(original)
+++ nemerle/trunk/ncc/typing/OverloadPossibility.n	Wed Jul  4 20:53:39 2007
@@ -365,7 +365,8 @@
     public static OnlyPossible (overloads : list [OverloadPossibility], expected : TyVar) 
                                           : list [OverloadPossibility]
     {
-      assert (!overloads.IsEmpty);
+      when (overloads.IsEmpty)
+        Nemerle.Imperative.Return ([]);
 
       def Manager = overloads.Head.Manager;
 

Modified: nemerle/trunk/ncc/typing/Typer-DelayedTyping.n
==============================================================================
--- nemerle/trunk/ncc/typing/Typer-DelayedTyping.n	(original)
+++ nemerle/trunk/ncc/typing/Typer-DelayedTyping.n	Wed Jul  4 20:53:39 2007
@@ -363,10 +363,13 @@
       public GetDescriptionForError () : list [string]
       {
         match (DtKind) {
+          | OverloadedOperator ([], t1, t2, name, _env, _seen) =>
+            "finding the operator " +
+            $"$name($t1" + (if (t2 != null) $", $t2" else "") + ")" :: []
           | OverloadedOperator (overloads, t1, t2, name, _env, _seen) =>
             def used (o) { o.UsedLastTime }
             "ambiguity between operator " +
-            $"$name($t1" + (if (t2 != null) $", $t2" else "") + ")"
+            $"$name($t1" + (if (t2 != null) $", $t2" else "") + ")" +
             " overloads:" :: 
             (if (overloads.Exists (used))
                overloads.Filter (used) 
@@ -615,8 +618,28 @@
               }
               Some (res)
               
-            | Some (MType.Fun) =>
-              Some (LookupOperatorIn (InternalType.Object, name))
+            | Some (MType.Fun (from, to)) =>
+              
+              match (from.AnyHint) {
+                | Some (MType.Tuple (args))
+                | Some (MType.Void) with args = []
+                | Some (x) with args = [x] =>
+                  def inst = InternalType.GetFunctionType (args.Length);
+                  Some (
+                    LookupOperatorIn (
+                      match (to.AnyHint) {
+                        | Some (MType.Void) =>
+                          MType.Class (inst.VoidTyCon, args)
+                        | Some => 
+                          MType.Class (inst.TyCon, (args + [to]))
+                        | None => 
+                          InternalType.Object
+                      }, 
+                      name
+                    )
+                  )
+                | _ => Some (LookupOperatorIn (InternalType.Object, name))
+              }
 
             | _ => None ()
           }
@@ -688,6 +711,7 @@
                   else
                   {
                     SetKind (Kind.OverloadedOperator (lst, t1, t2, name, env, seen));
+                    Resolve ();
                     true
                   }
                 | _ => false
@@ -716,9 +740,6 @@
            
                 when (o'.Length != overloads.Length || o'.Length == 1)
                   match (o') {
-                    | [] =>
-                      SetKind (Kind.Error ())
-                  
                     | [one] when hints == args
                               || hints > 0 && typer.BadnessAllowed > 0
                               || typer.BadnessAllowed > 1 =>
@@ -730,38 +751,21 @@
               }
            
           | Kind.Operator (t1, t2, name, env) =>
-            def operators =
-              match ((LookupOperator (t1, name), LookupOperator (t2, name))) {
-                | (Some (l1), Some (l2)) => Some (l1 + l2)
-                | (Some as s, None)
-                | (None, Some as s) => s
-                | (None, None) => None ()
-              }
             def operators = {
               def globals = env.LookupSymbol ([name], typer.current_type);
               mutable res = [];
               foreach (meth is IMethod in globals)
                 when (meth.IsStatic)
                   res = typer.ConstructMethodOverload (meth) + res;
-
-              match ((operators, res)) {
-                | (x, []) => x
-                | (Some (l1), l2) => Some (l1 + l2)
-                | (None, l) => Some (l)
-              }
+              when (LookupOperator (t1, name) is Some (lst))
+                res = lst + res;
+              when (LookupOperator (t2, name) is Some (lst))
+                res = lst + res;
+              res
             }
-            match (operators) {
-              | Some ([]) =>
-                ReportError (messenger, "cannot find the " + ToString ());
-                SetKind (Kind.Error ())
-                
-              | Some (lst) =>
-                SetKind (Kind.OverloadedOperator (lst, t1, t2, name, env, lst));
+            SetKind (Kind.OverloadedOperator (operators, t1, t2, name, env, operators));
                 Resolve ()
                 
-              | None => {}
-            }
-          
           | Kind.Resolved (expr) =>
             unless (typer.Expect (expected, expr.Type, "already resolved overload"))
               SetKind (Kind.Error ())