Index: htypechk.pas
===================================================================
--- htypechk.pas	(Revision 44153)
+++ htypechk.pas	(Arbeitskopie)
@@ -2497,6 +2497,7 @@
       end;
 
 
+
     procedure tcallcandidates.create_candidate_list(ignorevisibility,allowdefaultparas,objcidcall,explicitunit,searchhelpers,anoninherited:boolean;spezcontext:tspecializationcontext);
       var
         j     : integer;
@@ -2575,8 +2576,11 @@
         for j:=0 to ProcdefOverloadList.Count-1 do
           begin
             pd:=tprocdef(ProcdefOverloadList[j]);
+{$ifdef CHECK_FOR_POVERL_DUPLICATES}
             added:=false;
-
+{$else}
+            added:=true;
+{$endif}
             { only when the # of parameter are supported by the procedure and
               it is visible }
             if (FParalength>=pd.minparacount) and
@@ -2619,6 +2623,7 @@
                   cpoptions:=cpoptions+[cpo_rtlproc];
                 found:=false;
                 hp:=FCandidateProcs;
+{$ifdef CHECK_FOR_POVERL_DUPLICATES}
                 while assigned(hp) do
                   begin
                     if (compare_paras(hp^.data.paras,pd.paras,cp_value_equal_const,cpoptions)>=te_equal) and
@@ -2635,6 +2640,9 @@
                     proc_add(st,pd,objcidcall);
                     added:=true;
                   end;
+{$else}
+                proc_add(st,pd,objcidcall);
+{$endif}
               end;
 
             { we need to remove all specializations that were not used from their

Index: htypechk.pas
===================================================================
--- htypechk.pas	(Revision 44153)
+++ htypechk.pas	(Arbeitskopie)
@@ -2497,6 +2497,7 @@
       end;
 
 
+
     procedure tcallcandidates.create_candidate_list(ignorevisibility,allowdefaultparas,objcidcall,explicitunit,searchhelpers,anoninherited:boolean;spezcontext:tspecializationcontext);
       var
         j     : integer;
@@ -2619,6 +2620,7 @@
                   cpoptions:=cpoptions+[cpo_rtlproc];
                 found:=false;
                 hp:=FCandidateProcs;
+{$ifdef CHECK_FOR_POVERL_DUPLICATES}
                 while assigned(hp) do
                   begin
                     if (compare_paras(hp^.data.paras,pd.paras,cp_value_equal_const,cpoptions)>=te_equal) and
@@ -2635,6 +2637,10 @@
                     proc_add(st,pd,objcidcall);
                     added:=true;
                   end;
+{$else}
+                added:=true;
+                proc_add(st,pd,objcidcall);
+{$endif}
               end;
 
             { we need to remove all specializations that were not used from their

Compiling ./unix/classes.pp
Compiling ./objpas/types.pp
typshrd.inc(39,16) Warning: Location (LOC_REG) not equal to expectloc (LOC_CREG): temprefn
typshrd.inc(39,16) Warning: Location (LOC_REG) not equal to expectloc (LOC_CREG): blockn
typshrd.inc(39,31) Warning: Location (LOC_REG) not equal to expectloc (LOC_CREG): temprefn
typshrd.inc(39,31) Warning: Location (LOC_REG) not equal to expectloc (LOC_CREG): blockn
typshrd.inc(193,18) Warning: new call candidate: TYPES../build/pp2TRECT_$__$$_equal$TRECT$TRECT$$BOOLEAN existing:TYPES../build/pp2TRECT_$__$$_equal$TRECT$TRECT$$BOOLEAN
typshrd.inc(193,18) Warning: Overloaded callnode: equal(TRect,TRect)
typshrd.inc(193,18) Warning:   operator =(TRect;TRect):Boolean;
typshrd.inc(193,18) Warning:    ex: 0 eq: 0 l1: 0 l2: 0 l3: 0 l4: 0 l5: 0 l6: 0 oper: 0 ord:  0.00000000000000000000E+0000
typshrd.inc(193,18) Warning:     - TRect : incompatible
typshrd.inc(193,18) Warning:     - TRect : incompatible
typshrd.inc(193,18) Warning:   operator =(TRect;TRect):Boolean;
typshrd.inc(193,18) Warning:    ex: 0 eq: 0 l1: 0 l2: 0 l3: 0 l4: 0 l5: 0 l6: 0 oper: 0 ord:  0.00000000000000000000E+0000
typshrd.inc(193,18) Warning:     - TRect : incompatible
typshrd.inc(193,18) Warning:     - TRect : incompatible
typshrd.inc(193,18) Warning: Overloaded callnode: equal(TRect,TRect)
typshrd.inc(193,18) Warning:   operator =(const Variant;const Variant):Boolean;
typshrd.inc(193,18) Warning:    ex: 0 eq: 0 l1: 0 l2: 0 l3: 0 l4: 0 l5: 0 l6: 0 oper: 0 ord:  1.00000000000000000000E+0000
typshrd.inc(193,18) Warning:     - Variant : incompatible
typshrd.inc(193,18) Warning:     - Variant : incompatible
typshrd.inc(193,18) Warning:   operator =(TRect;TRect):Boolean;
typshrd.inc(193,18) Warning:    ex: 0 eq: 0 l1: 0 l2: 0 l3: 0 l4: 0 l5: 0 l6: 0 oper: 0 ord:  0.00000000000000000000E+0000
typshrd.inc(193,18) Warning:     - TRect : incompatible
typshrd.inc(193,18) Warning:     - TRect : incompatible
typshrd.inc(193,18) Warning:   operator =(TRect;TRect):Boolean;
typshrd.inc(193,18) Warning:    ex: 0 eq: 0 l1: 0 l2: 0 l3: 0 l4: 0 l5: 0 l6: 0 oper: 0 ord:  0.00000000000000000000E+0000
typshrd.inc(193,18) Warning:     - TRect : incompatible
typshrd.inc(193,18) Warning:     - TRect : incompatible
typshrd.inc(193,18) Error: Can't determine which overloaded function to call

type
T_uint = dword;


function maketypename(n : T_uint) : string;
begin
  maketypename := 'T'+hexstr(n,2*sizeof(T_uint));
end;

function makevarname(n : T_uint) : string;
begin
  makevarname := 'v'+hexstr(n,2*sizeof(T_uint));
end;


procedure maketype(n : T_uint);
begin
  writeln(maketypename(n),' = record');
  writeln('  f : byte;');
  writeln('end;');
  writeln;
end;

procedure maketypes(n : T_uint);
begin
  writeln('type');
  while (n>0) do begin
    maketype(n);
    dec(n);
  end;
  writeln;
end;

procedure makeoverloadproc(n : T_uint);
begin
  writeln('procedure someproc(a : ',maketypename(n),');');
  writeln('begin');
  writeln('  write(a.f);');
  writeln('end;');
  writeln;
end;

procedure makeoverloadprocs(n : T_uint);
begin
  while (n>0) do begin
    makeoverloadproc(n);
    dec(n);
  end;
end;


procedure makecall(n : T_uint);
begin
  write('  '+makevarname(n),'.f := ',random(256),';');
  writeln('  someproc(',makevarname(n),');');
end;

procedure makecalls(n : T_uint);
begin
  while (n>0) do begin
    makecall(n);
    dec(n);
  end;
end;

procedure makedecl(n : T_uint);
begin
  writeln('  '+makevarname(n),' : ',maketypename(n),';');
end;

procedure makedecls(n : T_uint);
begin
  writeln('var');
  while (n>0) do begin
    makedecl(n);
    dec(n);
  end;
end;

procedure makeallcallings(n : T_uint);
begin
  writeln('procedure makecalls();');
  makedecls(n);
  writeln('begin');
  makecalls(n);
  writeln('end;');
  writeln;
end;


var
n : T_uint;
w : word;

begin
  if (paramcount>=1) then begin
   val(paramstr(1),n);
  end else begin
    w := 1;    
  end;
  if not(w=0) then n:=100;
  maketypes(n);
  makeoverloadprocs(n);
  makeallcallings(n);
  writeln;
  writeln('begin');
  writeln('  makecalls();');
  writeln('  writeln;');
  writeln('end.');
end.

Index: compiler/symdef.pas
===================================================================
--- compiler/symdef.pas	(Revision 44246)
+++ compiler/symdef.pas	(Arbeitskopie)
@@ -849,6 +849,9 @@
             a routine that has to be internally generated by the compiler }
           synthetickind: tsynthetickind;
           visibility   : tvisibility;
+{$ifndef DISABLE_FAST_OVERLOAD_PATCH}
+          seenmarker : pointer; // used for filtering in tcandidate
+{$endif}
           constructor create(level:byte;doregister:boolean);virtual;
           constructor ppuload(ppufile:tcompilerppufile);
           destructor  destroy;override;
@@ -6010,6 +6013,9 @@
 {$else symansistr}
          _mangledname:=nil;
 {$endif symansistr}
+{$ifndef DISABLE_FAST_OVERLOAD_PATCH}
+         seenmarker := nil;
+{$endif}
          fileinfo:=current_filepos;
          extnumber:=$ffff;
          aliasnames:=TCmdStrList.create;
Index: compiler/htypechk.pas
===================================================================
--- compiler/htypechk.pas	(Revision 44246)
+++ compiler/htypechk.pas	(Arbeitskopie)
@@ -62,7 +62,10 @@
          cl6_count,
          coper_count : integer; { should be signed }
          ordinal_distance : double;
-         invalid     : boolean;
+         invalid : boolean;
+{$ifndef DISABLE_FAST_OVERLOAD_PATCH}
+         saved_validity : boolean;
+{$endif}
          wrongparanr : byte;
       end;
 
@@ -2579,7 +2582,11 @@
 
             { only when the # of parameter are supported by the procedure and
               it is visible }
+{$ifdef DISABLE_FAST_OVERLOAD_PATCH}
             if (FParalength>=pd.minparacount) and
+{$else}
+            if (pd.seenmarker<>pointer(self)) and (FParalength>=pd.minparacount) and
+{$endif}
                (
                 (
                  allowdefaultparas and
@@ -2619,6 +2626,7 @@
                   cpoptions:=cpoptions+[cpo_rtlproc];
                 found:=false;
                 hp:=FCandidateProcs;
+{$ifdef DISABLE_FAST_OVERLOAD_PATCH}
                 while assigned(hp) do
                   begin
                     if (compare_paras(hp^.data.paras,pd.paras,cp_value_equal_const,cpoptions)>=te_equal) and
@@ -2630,10 +2638,14 @@
                       end;
                     hp:=hp^.next;
                   end;
+{$endif}
                 if not found then
                   begin
                     proc_add(st,pd,objcidcall);
                     added:=true;
+{$ifndef DISABLE_FAST_OVERLOAD_PATCH}
+                    pd.seenmarker:=self;
+{$endif}
                   end;
               end;
 
@@ -2647,6 +2659,14 @@
                 pd.free;
               end;
           end;
+{$ifndef DISABLE_FAST_OVERLOAD_PATCH}
+        {cleanup modified duplicate pd markers}
+        hp := FCandidateProcs;
+        while assigned(hp) do begin
+          hp^.data.seenmarker := nil;
+          hp := hp^.next;
+        end;
+{$endif}
 
         calc_distance(st,objcidcall);
 
@@ -3233,6 +3253,8 @@
       end;
 
 
+
+
     function is_better_candidate(currpd,bestpd:pcandidate):integer;
       var
         res : integer;
@@ -3483,6 +3505,9 @@
       end;
 
 
+
+{$ifdef DISABLE_FAST_OVERLOAD_PATCH}
+
     function tcallcandidates.choose_best(var bestpd:tabstractprocdef; singlevariant: boolean):integer;
       var
         pd: tprocdef;
@@ -3570,6 +3595,199 @@
       end;
 
 
+{$else}
+
+    function compare_by_old_sortout_check(pd,bestpd:pcandidate):integer;
+      var cpoptions : tcompare_paras_options;
+      begin
+        { don't add duplicates, only compare visible parameters for the user }
+        cpoptions:=[cpo_ignorehidden];
+        if (po_compilerproc in bestpd^.data.procoptions) then cpoptions:=cpoptions+[cpo_compilerproc];
+        if (po_rtlproc in bestpd^.data.procoptions) then cpoptions:=cpoptions+[cpo_rtlproc];
+
+        compare_by_old_sortout_check := 0; // can't decide, bestpd probably wasn't sorted out in unpatched
+        if (compare_paras(pd^.data.paras,bestpd^.data.paras,cp_value_equal_const,cpoptions)>=te_equal) and
+             ( not(po_objc in bestpd^.data.procoptions) or (bestpd^.data.messageinf.str^=pd^.data.messageinf.str^)) 
+        then begin
+          compare_by_old_sortout_check := 1; // bestpd was sorted out before patch
+        end;
+     end;
+
+    function decide_restart(pd,bestpd:pcandidate) : boolean;
+    begin
+      decide_restart := false;
+      if assigned(bestpd) then begin
+        { don't restart if bestpd is marked invalid already }
+        if not bestpd^.invalid then begin
+          decide_restart := 0<>compare_by_old_sortout_check(pd,bestpd);
+        end;
+      end;
+    end;
+
+    procedure save_validity(c : pcandidate);
+    begin
+      while assigned(c) do begin
+        c^.saved_validity := c^.invalid;
+        c := c^.next;
+      end;
+    end;
+
+    procedure restore_validity(c : pcandidate);
+    begin
+      while assigned(c) do begin
+        c^.invalid := c^.saved_validity;
+        c := c^.next;
+      end;
+    end;
+
+
+    function tcallcandidates.choose_best(var bestpd:tabstractprocdef; singlevariant: boolean):integer;
+      var
+        pd: tprocdef;
+        besthpstart,
+        hp,hp2        : pcandidate;
+        cntpd,
+        res           : integer;
+        restart : boolean;
+      begin
+        {
+          Returns the number of candidates left and the
+          first candidate is returned in pdbest
+        }
+        if not(assigned(FCandidateProcs)) then begin
+          choose_best := 0;
+          exit;
+        end;
+
+        bestpd:=FCandidateProcs^.data;
+        if FCandidateProcs^.invalid 
+        then cntpd:=0
+        else cntpd:=1;
+
+        if assigned(FCandidateProcs^.next) then
+         begin
+           save_validity(FCandidateProcs);
+           restart := false;
+           { keep restarting, until there wasn't a sorted-out besthpstart }
+           repeat
+             besthpstart:=FCandidateProcs;
+             bestpd:=FCandidateProcs^.data;
+             if restart then begin
+               restore_validity(FCandidateProcs);
+               restart := false;
+             end;
+             { Setup the first procdef as best, only count it as a result
+               when it is valid }
+             if FCandidateProcs^.invalid 
+             then cntpd:=0
+             else cntpd:=1;
+             hp:=FCandidateProcs^.next;
+             while assigned(hp) and not(restart) do begin
+               restart := decide_restart(hp,besthpstart);
+               if not restart then begin
+                 if not singlevariant
+                 then res:=is_better_candidate(hp,besthpstart)
+                 else res:=is_better_candidate_single_variant(hp,besthpstart);
+               end;
+               if restart then begin
+                 { mark the sorted out invalid globally }
+                 besthpstart^.saved_validity := true;
+               end else if (res>0) then begin
+                 { hp is better, flag all procs to be incompatible }
+                 while (besthpstart<>hp) do begin
+                   besthpstart^.invalid:=true;
+                   besthpstart:=besthpstart^.next;
+                 end;
+                 { besthpstart is already set to hp }
+                 bestpd:=besthpstart^.data;
+                 cntpd:=1;
+               end else if (res<0) then begin
+                  { besthpstart is better, flag current hp to be incompatible }
+                  hp^.invalid:=true;
+               end else begin
+                 { res=0, both are valid }
+                 if not hp^.invalid then inc(cntpd);
+               end;
+               hp:=hp^.next;
+
+             end;
+           until not(restart);
+         end;
+
+        { check the alternate choices if they would have been sorted out before patch... }
+
+        { note we have procadded the candidates, so order is reversed procadd order here.
+          this was also used above: each sorted-out always has an "outsorter" counterpart 
+          deeper down the next chain 
+        }
+
+        { for the intial implementation, let's first do some more consistency checking}
+        res := 0;
+        hp := FCandidateProcs;
+        while assigned(hp) do begin
+          if not(hp^.invalid) then inc(res);
+          hp := hp^.next;
+        end;
+        if (res<>cntpd) then internalerror(202002161);
+
+        { check all valid choices for sortout }
+        cntpd := 0;
+        hp := FCandidateProcs;
+        while assigned(hp) do begin
+          if not(hp^.invalid) then begin
+            hp2 := hp^.next;
+            while assigned(hp2) do begin
+              if compare_by_old_sortout_check(hp2,hp)<>0 then begin
+                hp^.invalid := true;
+                hp2 := nil;
+              end else hp2:=hp2^.next;
+            end;
+            if not(hp^.invalid) then begin
+              inc(cntpd);
+              { check for the impossible event bestpd had become invalid}
+              if (cntpd=1)and(hp^.data<>bestpd) 
+              then internalerror(202002162);
+            end;
+          end;
+          hp := hp^.next;
+        end;
+
+
+        { if we've found one, check the procdefs ignored for overload choosing
+          to see whether they contain one from a child class with the same
+          parameters (so the overload choosing was not influenced by their
+          presence, but now that we've decided which overloaded version to call,
+          make sure we call the version closest in terms of visibility }
+        if cntpd=1 then
+          begin
+            for res:=0 to FIgnoredCandidateProcs.count-1 do
+              begin
+                pd:=tprocdef(FIgnoredCandidateProcs[res]);
+                { stop searching when we start comparing methods of parent of
+                  the struct in which the current best method was found }
+                if assigned(pd.struct) and
+                   (pd.struct<>tprocdef(bestpd).struct) and
+                   def_is_related(tprocdef(bestpd).struct,pd.struct) then
+                  break;
+                if (pd.proctypeoption=bestpd.proctypeoption) and
+                   ((pd.procoptions*[po_classmethod,po_methodpointer])=(bestpd.procoptions*[po_classmethod,po_methodpointer])) and
+                   (compare_paras(pd.paras,bestpd.paras,cp_all,[cpo_ignorehidden,cpo_ignoreuniv,cpo_openequalisexact])=te_exact) then
+                  begin
+                    { first one encountered is closest in terms of visibility }
+                    bestpd:=pd;
+                    break;
+                  end;
+              end;
+          end;
+        result:=cntpd;
+      end;
+
+{$endif}
+
+
+
+
+
     procedure tcallcandidates.find_wrong_para;
       var
         currparanr : smallint;