PATCH for Re: New c++ bug with conversion operators?

[Mark Mitchell <mark@markmitchell.com>]

  struct string
  {
    char* location;
    int length;

    operator const char*() const{return location;}
    /*  operator const char*() {return location;} */
    operator char*() {return location;}
  };

  main() {
    int i;
    string s1;
    const string s2=s1;

    i=strlen(s1);
    i=strlen(s2);
  }
  --------------end test.C--------------
  Here is the text of the warnings:
  telomere:~/devel/Psh.0.4.6.8> make test
  g++ -fno-rtti -fno-exceptions -Wall -g -O13 -DNDEBUG -mpentiumpro
  -I../include -fno-rtti -fno-exceptions   test.C   -o test
  test.C: In function `int main()':
  test.C:16: warning: choosing `string::operator char *()' over
  `string::operator const char *() const'
  test.C:16: warning:   for conversion from `string' to `const char *'
  test.C:16: warning:   because conversion sequence for `this' argument is
  better
  test.C:16: warning: choosing `string::operator char *()' over
  `string::operator const char *() const'
  test.C:16: warning:   for conversion from `string' to `const char *'
  test.C:16: warning:   because conversion sequence for `this' argument is
  better

Actually, g++ is doing the right thing here.  The overloading rules 
say (in [over.match.conv]):

  The argument list has one argument, which is the initializer expres-
  sion.  [Note: this argument will be compared against the implicit
  object parameter of the conversion functions.  ]

So, the fact that `s1' is not const does matter.  This is somewhat
surprising behavior, which is why g++ warns.

There's no reason for it to warn twice, though.  (And that might have
confused into thinking the second warning is about `s2', which it
isn't).  Jason, is the following patch OK?

-- 
Mark Mitchell 			mark@markmitchell.com
Mark Mitchell Consulting	http://www.markmitchell.com

1998-05-25  Mark Mitchell  <mark@markmitchell.com>

	* call.c (tourney): Don't do any extra comparisons.

Index: call.c
===================================================================
RCS file: /egcs/carton/cvsfiles/egcs/gcc/cp/call.c,v
retrieving revision 1.80
diff -c -p -r1.80 call.c
*** call.c	1998/05/24 23:55:15	1.80
--- call.c	1998/05/25 18:36:24
*************** tourney (candidates)
*** 4389,4394 ****
--- 4389,4395 ----
  {
    struct z_candidate *champ = candidates, *challenger;
    int fate;
+   int champ_compared_to_predecessor = 0;
  
    /* Walk through the list once, comparing each current champ to the next
       candidate, knocking out a candidate or two with each comparison.  */
*************** tourney (candidates)
*** 4405,4423 ****
  	      champ = challenger->next;
  	      if (champ == 0)
  		return 0;
  	    }
  	  else
! 	    champ = challenger;
  
  	  challenger = champ->next;
  	}
      }
  
    /* Make sure the champ is better than all the candidates it hasn't yet
!      been compared to.  This may do one more comparison than necessary.  Oh
!      well.  */
  
!   for (challenger = candidates; challenger != champ;
         challenger = challenger->next)
      {
        fate = joust (champ, challenger, 0);
--- 4406,4429 ----
  	      champ = challenger->next;
  	      if (champ == 0)
  		return 0;
+ 	      champ_compared_to_predecessor = 0;
  	    }
  	  else
! 	    {
! 	      champ = challenger;
! 	      champ_compared_to_predecessor = 1;
! 	    }
  
  	  challenger = champ->next;
  	}
      }
  
    /* Make sure the champ is better than all the candidates it hasn't yet
!      been compared to.  */
  
!   for (challenger = candidates; 
!        challenger != champ 
! 	 && !(champ_compared_to_predecessor && challenger->next == champ);
         challenger = challenger->next)
      {
        fate = joust (champ, challenger, 0);