mcs/mcs/report.cs

   1 //
   2 // report.cs: report errors and warnings.
   3 //
   4 // Author: Miguel de Icaza (miguel@ximian.com)
   5 //
   6 // (C) 2001 Ximian, Inc. (http://www.ximian.com)
   7 //
   8
   9 //
  10 // FIXME: currently our class library does not support custom number format strings
  11 //
  12 using System;
  13 using System.Text;
  14 using System.Collections;
  15 using System.Collections.Specialized;
  16 using System.Diagnostics;
  17 using System.Reflection;
  18
  19 namespace Mono.CSharp {
  20
  21         /// <summary>
  22         ///   This class is used to report errors and warnings t te user.
  23         /// </summary>
  24         public class Report {
  25                 /// <summary>
  26                 ///   Errors encountered so far
  27                 /// </summary>
  28                 static public int Errors;
  29
  30                 /// <summary>
  31                 ///   Warnings encountered so far
  32                 /// </summary>
  33                 static public int Warnings;
  34
  35                 /// <summary>
  36                 ///   Whether errors should be throw an exception
  37                 /// </summary>
  38                 static public bool Fatal;
  39
  40                 /// <summary>
  41                 ///   Whether warnings should be considered errors
  42                 /// </summary>
  43                 static public bool WarningsAreErrors;
  44
  45                 /// <summary>
  46                 ///   Whether to dump a stack trace on errors.
  47                 /// </summary>
  48                 static public bool Stacktrace;
  49
  50                 //
  51                 // If the 'expected' error code is reported then the
  52                 // compilation succeeds.
  53                 //
  54                 // Used for the test suite to excercise the error codes
  55                 //
  56                 static int expected_error = 0;
  57
  58                 //
  59                 // Keeps track of the warnings that we are ignoring
  60                 //
  61                 static Hashtable warning_ignore_table;
  62
  63                 static Hashtable warning_regions_table;
  64
  65                 /// <summary>
  66                 /// List of symbols related to reported error/warning. You have to fill it before error/warning is reported.
  67                 /// </summary>
  68                 static StringCollection related_symbols = new StringCollection ();
  69
  70                 abstract class AbstractMessage {
  71
  72                         static void Check (int code)
  73                         {
  74                                 if (code == expected_error) {
  75                                         Environment.Exit (0);
  76                                 }
  77                         }
  78
  79                         public abstract bool IsWarning { get; }
  80
  81                         public abstract string MessageType { get; }
  82
  83                         public virtual void Print (int code, string location, string text)
  84                         {
  85                                 if (code < 0)
  86                                         code = 8000-code;
  87
  88                                 StringBuilder msg = new StringBuilder ();
  89                                 if (location.Length != 0) {
  90                                         msg.Append (location);
  91                                         msg.Append (' ');
  92                                 }
  93                                 msg.AppendFormat ("{0} CS{1:0000}: {2}", MessageType, code, text);
  94                                 Console.Error.WriteLine (msg.ToString ());
  95
  96                                 foreach (string s in related_symbols) {
  97                                         Console.Error.WriteLine (String.Concat (s, MessageType, ')'));
  98                                 }
  99                                 related_symbols.Clear ();
 100
 101                                 if (Stacktrace)
 102                                         Console.WriteLine (FriendlyStackTrace (new StackTrace (true)));
 103
 104                                 if (Fatal) {
 105                                         if (!IsWarning || WarningsAreErrors)
 106                                                 throw new Exception (text);
 107                                 }
 108
 109                                 Check (code);
 110                         }
 111
 112                         public virtual void Print (int code, Location location, string text)
 113                         {
 114                                 if (location.Equals (Location.Null)) {
 115                                         Print (code, "", text);
 116                                         return;
 117                                 }
 118                                 Print (code, String.Format ("{0}({1})", location.Name, location.Row), text);
 119                         }
 120                 }
 121
 122                 sealed class WarningMessage: AbstractMessage {
 123                         Location loc = Location.Null;
 124                         readonly int Level;
 125
 126                         public WarningMessage ():
 127                                 this (-1) {}
 128
 129                         public WarningMessage (int level)
 130                         {
 131                                 Level = level;
 132                         }
 133
 134                         public override bool IsWarning {
 135                                 get { return true; }
 136                         }
 137
 138                         bool IsEnabled (int code)
 139                         {
 140                                 if (RootContext.WarningLevel < Level)
 141                                         return false;
 142
 143                                 if (warning_ignore_table != null) {
 144                                         if (warning_ignore_table.Contains (code)) {
 145                                                 return false;
 146                                         }
 147                                 }
 148
 149                                 if (warning_regions_table == null || loc.Equals (Location.Null))
 150                                         return true;
 151
 152                                 WarningRegions regions = (WarningRegions)warning_regions_table [loc.Name];
 153                                 return regions.IsWarningEnabled (code, loc.Row);
 154                         }
 155
 156                         public override void Print(int code, string location, string text)
 157                         {
 158                                 if (!IsEnabled (code)) {
 159                                         related_symbols.Clear ();
 160                                         return;
 161                                 }
 162
 163                                 if (WarningsAreErrors) {
 164                                         new ErrorMessage ().Print (code, location, text);
 165                                         return;
 166                                 }
 167
 168                                 Warnings++;
 169                                 base.Print (code, location, text);
 170                         }
 171
 172                         public override void Print(int code, Location location, string text)
 173                         {
 174                                 loc = location;
 175                                 base.Print (code, location, text);
 176                         }
 177
 178                         public override string MessageType {
 179                                 get {
 180                                         return "warning";
 181                                 }
 182                         }
 183                 }
 184
 185                 sealed class ErrorMessage: AbstractMessage {
 186
 187                         public override void Print(int code, string location, string text)
 188                         {
 189                                 Errors++;
 190                                 base.Print (code, location, text);
 191                         }
 192
 193                         public override bool IsWarning {
 194                                 get { return false; }
 195                         }
 196
 197                         public override string MessageType {
 198                                 get {
 199                                         return "error";
 200                                 }
 201                         }
 202
 203                 }
 204
 205                 public static void FeatureIsNotStandardized (Location loc, string feature)
 206                 {
 207                         Report.Error (1644, loc, "Feature '{0}' cannot be used because it is not part of the standardized ISO C# language specification", feature);
 208                 }
 209
 210                 public static string FriendlyStackTrace (Exception e)
 211                 {
 212                         return FriendlyStackTrace (new StackTrace (e, true));
 213                 }
 214
 215                 static string FriendlyStackTrace (StackTrace t)
 216                 {
 217                         StringBuilder sb = new StringBuilder ();
 218
 219                         bool foundUserCode = false;
 220
 221                         for (int i = 0; i < t.FrameCount; i++) {
 222                                 StackFrame f = t.GetFrame (i);
 223                                 MethodBase mb = f.GetMethod ();
 224
 225                                 if (!foundUserCode && mb.ReflectedType == typeof (Report))
 226                                         continue;
 227
 228                                 foundUserCode = true;
 229
 230                                 sb.Append ("\tin ");
 231
 232                                 if (f.GetFileLineNumber () > 0)
 233                                         sb.AppendFormat ("(at {0}:{1}) ", f.GetFileName (), f.GetFileLineNumber ());
 234
 235                                 sb.AppendFormat ("{0}.{1} (", mb.ReflectedType.Name, mb.Name);
 236
 237                                 bool first = true;
 238                                 foreach (ParameterInfo pi in mb.GetParameters ()) {
 239                                         if (!first)
 240                                                 sb.Append (", ");
 241                                         first = false;
 242
 243                                         sb.Append (TypeManager.CSharpName (pi.ParameterType));
 244                                 }
 245                                 sb.Append (")\n");
 246                         }
 247
 248                         return sb.ToString ();
 249                 }
 250
 251                 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 252                 // IF YOU ADD A NEW WARNING YOU HAVE TO DUPLICATE ITS ID HERE
 253                 //
 254                 public static bool IsValidWarning (int code)
 255                 {
 256                         int[] all_warnings = new int[] {
 257                                 28, 67, 78, 105, 108, 109, 114, 192, 168, 169, 183, 184, 219, 251, 612, 618, 626, 628, 642, 649,
 258                                 659, 660, 661, 672, 1030, 1522, 1616, 1691, 1692, 1901, 2002, 2023, 3012, 3019, 8024, 8028
 259                         };
 260
 261                         foreach (int i in all_warnings) {
 262                                 if (i == code)
 263                                         return true;
 264                         }
 265                         return false;
 266                 }
 267
 268                 static public void LocationOfPreviousError (Location loc)
 269                 {
 270                         Console.Error.WriteLine (String.Format ("{0}({1}) (Location of symbol related to previous error)", loc.Name, loc.Row));
 271                 }
 272
 273                 static public void RuntimeMissingSupport (Location loc, string feature)
 274                 {
 275                         Report.Error (-88, loc, "Your .NET Runtime does not support '{0}'. Please use the latest Mono runtime instead.", feature);
 276                 }
 277
 278                 /// <summary>
 279                 /// In most error cases is very useful to have information about symbol that caused the error.
 280                 /// Call this method before you call Report.Error when it makes sense.
 281                 /// </summary>
 282                 static public void SymbolRelatedToPreviousError (Location loc, string symbol)
 283                 {
 284                         SymbolRelatedToPreviousError (String.Format ("{0}({1})", loc.Name, loc.Row), symbol);
 285                 }
 286
 287                 static public void SymbolRelatedToPreviousError (MemberInfo mi)
 288                 {
 289                         TypeContainer temp_ds = TypeManager.LookupTypeContainer (mi.DeclaringType);
 290                         if (temp_ds == null) {
 291                                 SymbolRelatedToPreviousError (mi.DeclaringType.Assembly.Location, TypeManager.GetFullNameSignature (mi));
 292                         } else {
 293                                 if (mi is MethodBase) {
 294                                         IMethodData md = TypeManager.GetMethod ((MethodBase)mi);
 295                                         SymbolRelatedToPreviousError (md.Location, md.GetSignatureForError (temp_ds));
 296                                         return;
 297                                 }
 298
 299                                 string name = String.Concat (temp_ds.Name, ".", mi.Name);
 300                                 MemberCore mc = temp_ds.GetDefinition (name);
 301                                 SymbolRelatedToPreviousError (mc);
 302                         }
 303                 }
 304
 305                 static public void SymbolRelatedToPreviousError (MemberCore mc)
 306                 {
 307                         SymbolRelatedToPreviousError (mc.Location, mc.GetSignatureForError ());
 308                 }
 309
 310                 static public void SymbolRelatedToPreviousError (Type type)
 311                 {
 312                         DeclSpace temp_ds = TypeManager.LookupDeclSpace (type);
 313                         if (temp_ds == null)
 314                                 SymbolRelatedToPreviousError (type.Assembly.Location, TypeManager.CSharpName (type));
 315                         else
 316                                 SymbolRelatedToPreviousError (temp_ds.Location, TypeManager.CSharpName (type));
 317                 }
 318
 319                 static void SymbolRelatedToPreviousError (string loc, string symbol)
 320                 {
 321                         related_symbols.Add (String.Format ("{0}: '{1}' (name of symbol related to previous ", loc, symbol));
 322                 }
 323
 324                 public static WarningRegions RegisterWarningRegion (Location location)
 325                 {
 326                         if (warning_regions_table == null)
 327                                 warning_regions_table = new Hashtable ();
 328
 329                         WarningRegions regions = (WarningRegions)warning_regions_table [location.Name];
 330                         if (regions == null) {
 331                                 regions = new WarningRegions ();
 332                                 warning_regions_table.Add (location.Name, regions);
 333                         }
 334                         return regions;
 335                 }
 336
 337                 static public void Warning (int code, int level, Location loc, string format, params object[] args)
 338                 {
 339                         WarningMessage w = new WarningMessage (level);
 340                         w.Print (code, loc, String.Format (format, args));
 341                 }
 342
 343                 static public void Warning (int code, Location loc, string format, params object[] args)
 344                 {
 345                         WarningMessage w = new WarningMessage ();
 346                         w.Print (code, loc, String.Format (format, args));
 347                 }
 348
 349                 static public void Warning (int code, string format, params object[] args)
 350                 {
 351                         Warning (code, Location.Null, String.Format (format, args));
 352                 }
 353
 354                 /// <summary>
 355                 /// Did you test your WarningLevel, that you use this method
 356                 /// </summary>
 357                 static public void Warning (int code, string text)
 358                 {
 359                         Warning (code, Location.Null, text);
 360                 }
 361
 362                 static public void Error (int code, string format, params object[] args)
 363                 {
 364                         Error (code, Location.Null, String.Format (format, args));
 365                 }
 366
 367                 static public void Error (int code, Location loc, string format, params object[] args)
 368                 {
 369                         ErrorMessage e = new ErrorMessage ();
 370                         e.Print (code, loc, String.Format (format, args));
 371                 }
 372
 373                 static public void SetIgnoreWarning (int code)
 374                 {
 375                         if (warning_ignore_table == null)
 376                                 warning_ignore_table = new Hashtable ();
 377
 378                         warning_ignore_table [code] = true;
 379                 }
 380
 381                 static public int ExpectedError {
 382                         set {
 383                                 expected_error = value;
 384                         }
 385                         get {
 386                                 return expected_error;
 387                         }
 388                 }
 389
 390                 public static int DebugFlags = 0;
 391
 392                 [Conditional ("MCS_DEBUG")]
 393                 static public void Debug (string message, params object[] args)
 394                 {
 395                         Debug (4, message, args);
 396                 }
 397
 398                 [Conditional ("MCS_DEBUG")]
 399                 static public void Debug (int category, string message, params object[] args)
 400                 {
 401                         if ((category & DebugFlags) == 0)
 402                                 return;
 403
 404                         StringBuilder sb = new StringBuilder (message);
 405
 406                         if ((args != null) && (args.Length > 0)) {
 407                                 sb.Append (": ");
 408
 409                                 bool first = true;
 410                                 foreach (object arg in args) {
 411                                         if (first)
 412                                                 first = false;
 413                                         else
 414                                                 sb.Append (", ");
 415                                         if (arg == null)
 416                                                 sb.Append ("null");
 417                                         else if (arg is ICollection)
 418                                                 sb.Append (PrintCollection ((ICollection) arg));
 419                                         else
 420                                                 sb.Append (arg);
 421                                 }
 422                         }
 423
 424                         Console.WriteLine (sb.ToString ());
 425                 }
 426
 427                 static public string PrintCollection (ICollection collection)
 428                 {
 429                         StringBuilder sb = new StringBuilder ();
 430
 431                         sb.Append (collection.GetType ());
 432                         sb.Append ("(");
 433
 434                         bool first = true;
 435                         foreach (object o in collection) {
 436                                 if (first)
 437                                         first = false;
 438                                 else
 439                                         sb.Append (", ");
 440                                 sb.Append (o);
 441                         }
 442
 443                         sb.Append (")");
 444                         return sb.ToString ();
 445                 }
 446         }
 447
 448         public enum TimerType {
 449                 FindMembers     = 0,
 450                 TcFindMembers   = 1,
 451                 MemberLookup    = 2,
 452                 CachedLookup    = 3,
 453                 CacheInit       = 4,
 454                 MiscTimer       = 5,
 455                 CountTimers     = 6
 456         }
 457
 458         public enum CounterType {
 459                 FindMembers     = 0,
 460                 MemberCache     = 1,
 461                 MiscCounter     = 2,
 462                 CountCounters   = 3
 463         }
 464
 465         public class Timer
 466         {
 467                 static DateTime[] timer_start;
 468                 static TimeSpan[] timers;
 469                 static long[] timer_counters;
 470                 static long[] counters;
 471
 472                 static Timer ()
 473                 {
 474                         timer_start = new DateTime [(int) TimerType.CountTimers];
 475                         timers = new TimeSpan [(int) TimerType.CountTimers];
 476                         timer_counters = new long [(int) TimerType.CountTimers];
 477                         counters = new long [(int) CounterType.CountCounters];
 478
 479                         for (int i = 0; i < (int) TimerType.CountTimers; i++) {
 480                                 timer_start [i] = DateTime.Now;
 481                                 timers [i] = TimeSpan.Zero;
 482                         }
 483                 }
 484
 485                 [Conditional("TIMER")]
 486                 static public void IncrementCounter (CounterType which)
 487                 {
 488                         ++counters [(int) which];
 489                 }
 490
 491                 [Conditional("TIMER")]
 492                 static public void StartTimer (TimerType which)
 493                 {
 494                         timer_start [(int) which] = DateTime.Now;
 495                 }
 496
 497                 [Conditional("TIMER")]
 498                 static public void StopTimer (TimerType which)
 499                 {
 500                         timers [(int) which] += DateTime.Now - timer_start [(int) which];
 501                         ++timer_counters [(int) which];
 502                 }
 503
 504                 [Conditional("TIMER")]
 505                 static public void ShowTimers ()
 506                 {
 507                         ShowTimer (TimerType.FindMembers, "- FindMembers timer");
 508                         ShowTimer (TimerType.TcFindMembers, "- TypeContainer.FindMembers timer");
 509                         ShowTimer (TimerType.MemberLookup, "- MemberLookup timer");
 510                         ShowTimer (TimerType.CachedLookup, "- CachedLookup timer");
 511                         ShowTimer (TimerType.CacheInit, "- Cache init");
 512                         ShowTimer (TimerType.MiscTimer, "- Misc timer");
 513
 514                         ShowCounter (CounterType.FindMembers, "- Find members");
 515                         ShowCounter (CounterType.MemberCache, "- Member cache");
 516                         ShowCounter (CounterType.MiscCounter, "- Misc counter");
 517                 }
 518
 519                 static public void ShowCounter (CounterType which, string msg)
 520                 {
 521                         Console.WriteLine ("{0} {1}", counters [(int) which], msg);
 522                 }
 523
 524                 static public void ShowTimer (TimerType which, string msg)
 525                 {
 526                         Console.WriteLine (
 527                                 "[{0:00}:{1:000}] {2} (used {3} times)",
 528                                 (int) timers [(int) which].TotalSeconds,
 529                                 timers [(int) which].Milliseconds, msg,
 530                                 timer_counters [(int) which]);
 531                 }
 532         }
 533
 534         public class InternalErrorException : Exception {
 535                 public InternalErrorException ()
 536                         : base ("Internal error")
 537                 {
 538                 }
 539
 540                 public InternalErrorException (string message)
 541                         : base (message)
 542                 {
 543                 }
 544         }
 545
 546         /// <summary>
 547         /// Handles #pragma warning
 548         /// </summary>
 549         public class WarningRegions {
 550
 551                 abstract class PragmaCmd
 552                 {
 553                         public int Line;
 554
 555                         protected PragmaCmd (int line)
 556                         {
 557                                 Line = line;
 558                         }
 559
 560                         public abstract bool IsEnabled (int code, bool previous);
 561                 }
 562
 563                 class Disable: PragmaCmd
 564                 {
 565                         int code;
 566                         public Disable (int line, int code)
 567                                 : base (line)
 568                         {
 569                                 this.code = code;
 570                         }
 571
 572                         public override bool IsEnabled (int code, bool previous)
 573                         {
 574                                 return this.code == code ? false : previous;
 575                         }
 576                 }
 577
 578                 class DisableAll: PragmaCmd
 579                 {
 580                         public DisableAll (int line)
 581                                 : base (line) {}
 582
 583                         public override bool IsEnabled(int code, bool previous)
 584                         {
 585                                 return false;
 586                         }
 587                 }
 588
 589                 class Enable: PragmaCmd
 590                 {
 591                         int code;
 592                         public Enable (int line, int code)
 593                                 : base (line)
 594                         {
 595                                 this.code = code;
 596                         }
 597
 598                         public override bool IsEnabled(int code, bool previous)
 599                         {
 600                                 return this.code == code ? true : previous;
 601                         }
 602                 }
 603
 604                 class EnableAll: PragmaCmd
 605                 {
 606                         public EnableAll (int line)
 607                                 : base (line) {}
 608
 609                         public override bool IsEnabled(int code, bool previous)
 610                         {
 611                                 return true;
 612                         }
 613                 }
 614
 615
 616                 ArrayList regions = new ArrayList ();
 617
 618                 public void WarningDisable (int line)
 619                 {
 620                         regions.Add (new DisableAll (line));
 621                 }
 622
 623                 public void WarningDisable (Location location, int code)
 624                 {
 625                         if (CheckWarningCode (code, location))
 626                                 regions.Add (new Disable (location.Row, code));
 627                 }
 628
 629                 public void WarningEnable (int line)
 630                 {
 631                         regions.Add (new EnableAll (line));
 632                 }
 633
 634                 public void WarningEnable (Location location, int code)
 635                 {
 636                         if (CheckWarningCode (code, location))
 637                                 regions.Add (new Enable (location.Row, code));
 638                 }
 639
 640                 public bool IsWarningEnabled (int code, int src_line)
 641                 {
 642                         bool result = true;
 643                         foreach (PragmaCmd pragma in regions) {
 644                                 if (src_line < pragma.Line)
 645                                         break;
 646
 647                                 result = pragma.IsEnabled (code, result);
 648                         }
 649                         return result;
 650                 }
 651
 652                 bool CheckWarningCode (int code, Location loc)
 653                 {
 654                         if (Report.IsValidWarning (code))
 655                                 return true;
 656
 657                         Report.Warning (1691, 1, loc, "'{0}' is not a valid warning number", code);
 658                         return false;
 659                 }
 660         }
 661 }