mcs/mcs/ChangeLog

   1 2002-09-08  Miguel de Icaza  <miguel@ximian.com>
   2
   3         * namespace.cs (UsingEntry): New struct to hold the name of the
   4         using definition, the location where it is defined, and whether it
   5         has been used in a successful type lookup.
   6
   7         * rootcontext.cs (NamespaceLookup): Use UsingEntries instead of
   8         strings.
   9
  10         * decl.cs: ditto.
  11
  12 2002-09-06  Ravi Pratap  <ravi@ximian.com>
  13
  14         * attribute.cs : Fix incorrect code which relied on catching
  15         a NullReferenceException to detect a null being passed in
  16         where an object was expected.
  17
  18 2002-09-06  Miguel de Icaza  <miguel@ximian.com>
  19
  20         * statement.cs (Try): flag the catch variable as assigned
  21
  22         * expression.cs (Cast): Simplified by using ResolveType instead of
  23         manually resolving.
  24
  25         * statement.cs (Catch): Fix bug by using ResolveType.
  26
  27 2002-09-06  Ravi Pratap  <ravi@ximian.com>
  28
  29         * expression.cs (BetterConversion): Special case for when we have
  30         a NullLiteral as the argument and we have to choose between string
  31         and object types - we choose string the way csc does.
  32
  33         * attribute.cs (Attribute.Resolve): Catch the
  34         NullReferenceException and report error #182 since the Mono
  35         runtime no more has the bug and having this exception raised means
  36         we tried to select a constructor which takes an object and is
  37         passed a null.
  38
  39 2002-09-05  Ravi Pratap  <ravi@ximian.com>
  40
  41         * expression.cs (Invocation.OverloadResolve): Flag a nicer error
  42         message (1502, 1503) when we can't locate a method after overload
  43         resolution. This is much more informative and closes the bug
  44         Miguel reported.
  45
  46         * interface.cs (PopulateMethod): Return if there are no argument
  47         types. Fixes a NullReferenceException bug.
  48
  49         * attribute.cs (Attribute.Resolve): Ensure we allow TypeOf
  50         expressions too. Previously we were checking only in one place for
  51         positional arguments leaving out named arguments.
  52
  53         * ecore.cs (ImplicitNumericConversion): Conversion from underlying
  54         type to the enum type is not allowed. Remove code corresponding to
  55         that.
  56
  57         (ConvertNumericExplicit): Allow explicit conversions from
  58         the underlying type to enum type. This precisely follows the spec
  59         and closes a bug filed by Gonzalo.
  60
  61 2002-09-04  Gonzalo Paniagua Javier <gonzalo@ximian.com>
  62
  63         * compiler.csproj:
  64         * compiler.csproj.user: patch from Adam Chester (achester@bigpond.com).
  65
  66 2002-09-03  Miguel de Icaza  <miguel@ximian.com>
  67
  68         * statement.cs (SwitchLabel.ResolveAndReduce): In the string case,
  69         it was important that we stored the right value after the
  70         reduction in `converted'.
  71
  72 2002-09-04  Martin Baulig  <martin@gnome.org>
  73
  74         * location.cs (Location.SymbolDocument): Use full pathnames for the
  75         source files.
  76
  77 2002-08-30  Miguel de Icaza  <miguel@ximian.com>
  78
  79         * expression.cs (ComposedCast): Use DeclSparce.ResolveType instead
  80         of the expression resolve mechanism, because that will catch the
  81         SimpleName error failures.
  82
  83         (Conditional): If we can not resolve the
  84         expression, return, do not crash.
  85
  86 2002-08-29  Gonzalo Paniagua Javier <gonzalo@ximian.com>
  87
  88         * cs-tokenizer.cs:
  89         (location): display token name instead of its number.
  90
  91 2002-08-28  Martin Baulig  <martin@gnome.org>
  92
  93         * expression.cs (Binary.ResolveOperator): Don't silently return
  94         but return an error if an operator cannot be applied between two
  95         enum types.
  96
  97 2002-08-28  Martin Baulig  <martin@gnome.org>
  98
  99         * class.cs (Constructor.Define): Set the permission attributes
 100         correctly instead of making all constructors public.
 101
 102 2002-08-28  Martin Baulig  <martin@gnome.org>
 103
 104         * ecore.cs (Expression.DoResolve): Do a TypeManager.MemberLook
 105         for private members before reporting a CS0103; if we find anything,
 106         it's a CS0122.
 107
 108 2002-08-28  Martin Baulig  <martin@gnome.org>
 109
 110         * typemanager.cs (TypeManager.FilterWithClosure): It's not enough
 111         to check whether `closure_start_type == closure_invocation_type',
 112         we also need to check whether `m.DeclaringType == closure_invocation_type'
 113         before bypassing the permission checks.  We might be accessing
 114         protected/private members from the base class.
 115         (TypeManager.RealMemberLookup): Only set private_ok if private
 116         members were requested via BindingFlags.NonPublic.
 117
 118         * ecore.cs (MethodGroupExpr.IsExplicitImpl): New property.
 119
 120         * expression.cs (MemberAccess.ResolveMemberAccess): Set
 121         MethodGroupExpr.IsExplicitImpl if appropriate.
 122         (Invocation.DoResolve): Don't report the CS0120 for explicit
 123         interface implementations.
 124
 125 2002-08-27  Martin Baulig  <martin@gnome.org>
 126
 127         * expression.cs (Invocation.DoResolve): If this is a static
 128         method and we don't have an InstanceExpression, we must report
 129         a CS0120.
 130
 131 2002-08-25  Martin Baulig  <martin@gnome.org>
 132
 133         * expression.cs (Binary.ResolveOperator): Don't allow `!=' and
 134         `==' between a valuetype and an object.
 135
 136 2002-08-25  Miguel de Icaza  <miguel@ximian.com>
 137
 138         * ecore.cs (TypeExpr): Provide a ToString method.
 139
 140 2002-08-24  Martin Baulig  <martin@gnome.org>
 141
 142         * codegen.cs (CodeGen.InitMonoSymbolWriter): The symbol file is
 143         now called proggie.dbg and it's a binary file.
 144
 145 2002-08-23  Martin Baulig  <martin@gnome.org>
 146
 147         * decl.cs (MemberCache.AddMethods): Ignore varargs methods.
 148
 149 2002-08-23  Martin Baulig  <martin@gnome.org>
 150
 151         * struct.cs (MyStructInfo.ctor): Make this work with empty
 152         structs; it's not allowed to use foreach() on null.
 153
 154 2002-08-23  Martin Baulig  <martin@gnome.org>
 155
 156         * codegen.cs (CodeGen.InitMonoSymbolWriter): Tell the symbol
 157         writer the full pathname of the generated assembly.
 158
 159 2002-08-23  Martin Baulig  <martin@gnome.org>
 160
 161         * statements.cs (FlowBranching.UsageVector.MergeChildren):
 162         A `finally' block never returns or breaks; improved handling of
 163         unreachable code.
 164
 165 2002-08-23  Martin Baulig  <martin@gnome.org>
 166
 167         * statement.cs (Throw.Resolve): Allow `throw null'.
 168
 169 2002-08-23  Martin Baulig  <martin@gnome.org>
 170
 171         * expression.cs (MemberAccess.ResolveMemberAccess): If this is an
 172         EventExpr, don't do a DeclaredOnly MemberLookup, but check whether
 173         `ee.EventInfo.DeclaringType == ec.ContainerType'.  The
 174         MemberLookup would return a wrong event if this is an explicit
 175         interface implementation and the class has an event with the same
 176         name.
 177
 178 2002-08-23  Martin Baulig  <martin@gnome.org>
 179
 180         * statement.cs (Block.AddChildVariableNames): New public method.
 181         (Block.AddChildVariableName): Likewise.
 182         (Block.IsVariableNameUsedInChildBlock): Likewise.
 183         (Block.AddVariable): Check whether a variable name has already
 184         been used in a child block.
 185
 186         * cs-parser.jay (declare_local_variables): Mark all variable names
 187         from the current block as being used in a child block in the
 188         implicit block.
 189
 190 2002-08-23  Martin Baulig  <martin@gnome.org>
 191
 192         * codegen.cs (CodeGen.InitializeSymbolWriter): Abort if we can't
 193         find the symbol writer.
 194
 195         * driver.cs: csc also allows the arguments to /define being
 196         separated by commas, not only by semicolons.
 197
 198 2002-08-23  Martin Baulig  <martin@gnome.org>
 199
 200         * interface.cs (Interface.GetMembers): Added static check for events.
 201
 202 2002-08-15  Martin Baulig  <martin@gnome.org>
 203
 204         * class.cs (MethodData.EmitDestructor): In the Expression.MemberLookup
 205         call, use ec.ContainerType.BaseType as queried_type and invocation_type.
 206
 207         * ecore.cs (Expression.MemberLookup): Added documentation and explained
 208         why the MethodData.EmitDestructor() change was necessary.
 209
 210 2002-08-20  Martin Baulig  <martin@gnome.org>
 211
 212         * class.cs (TypeContainer.FindMembers): Added static check for events.
 213
 214         * decl.cs (MemberCache.AddMembers): Handle events like normal members.
 215
 216         * typemanager.cs (TypeHandle.GetMembers): When queried for events only,
 217         use Type.GetEvents(), not Type.FindMembers().
 218
 219 2002-08-20  Martin Baulig  <martin@gnome.org>
 220
 221         * decl.cs (MemberCache): Added a special method cache which will
 222         be used for method-only searched.  This ensures that a method
 223         search will return a MethodInfo with the correct ReflectedType for
 224         inherited methods.
 225
 226 2002-08-20  Martin Baulig  <martin@gnome.org>
 227
 228         * decl.cs (DeclSpace.FindMembers): Made this public.
 229
 230 2002-08-20  Gonzalo Paniagua Javier <gonzalo@ximian.com>
 231
 232         * delegate.cs: fixed build on windows.
 233         [FIXME:  Filed as bug #29150: MCS must report these errors.]
 234
 235 2002-08-19  Ravi Pratap  <ravi@ximian.com>
 236
 237         * ecore.cs (StandardConversionExists): Return a false
 238         if we are trying to convert the void type to anything else
 239         since that is not allowed.
 240
 241         * delegate.cs (DelegateInvocation.DoResolve): Ensure that
 242         we flag error 70 in the event an event is trying to be accessed
 243         directly from outside the declaring type.
 244
 245 2002-08-20  Martin Baulig  <martin@gnome.org>
 246
 247         * typemanager.cs, decl.cs: Moved MemberList, IMemberContainer and
 248         MemberCache from typemanager.cs to decl.cs.
 249
 250 2002-08-19  Martin Baulig  <martin@gnome.org>
 251
 252         * class.cs (TypeContainer): Implement IMemberContainer.
 253         (TypeContainer.DefineMembers): Create the MemberCache.
 254         (TypeContainer.FindMembers): Do better BindingFlags checking; only
 255         return public members if BindingFlags.Public was given, check
 256         whether members are static.
 257
 258 2002-08-16  Martin Baulig  <martin@gnome.org>
 259
 260         * decl.cs (DeclSpace.Define): Splitted this in Define and
 261         DefineMembers.  DefineMembers is called first and initializes the
 262         MemberCache.
 263
 264         * rootcontext.cs (RootContext.DefineMembers): New function.  Calls
 265         DefineMembers() on all our DeclSpaces.
 266
 267         * class.cs (TypeContainer.Define): Moved all code to DefineMembers(),
 268         but call DefineMembers() on all nested interfaces.  We call their
 269         Define() in our new Define() function.
 270
 271         * interface.cs (Interface): Implement IMemberContainer.
 272         (Interface.Define): Moved all code except the attribute stuf to
 273         DefineMembers().
 274         (Interface.DefineMembers): Initialize the member cache.
 275
 276         * typemanager.cs (IMemberFinder): Removed this interface, we don't
 277         need this anymore since we can use MemberCache.FindMembers directly.
 278
 279 2002-08-19  Martin Baulig  <martin@gnome.org>
 280
 281         * typemanager.cs (MemberCache): When creating the cache for an
 282         interface type, add all inherited members.
 283         (TypeManager.MemberLookup_FindMembers): Changed `ref bool searching'
 284         to `out bool used_cache' and documented it.
 285         (TypeManager.MemberLookup): If we already used the cache in the first
 286         iteration, we don't need to do the interfaces check.
 287
 288 2002-08-19  Martin Baulig  <martin@gnome.org>
 289
 290         * decl.cs (DeclSpace.FindMembers): New abstract method.  Moved this
 291         here from IMemberFinder and don't implement this interface anymore.
 292         (DeclSpace.MemberCache): Moved here from IMemberFinder.
 293
 294         * typemanager.cs (IMemberFinder): This interface is now only used by
 295         classes which actually support the member cache.
 296         (TypeManager.builder_to_member_finder): Renamed to builder_to_declspace
 297         since we only put DeclSpaces into this Hashtable.
 298         (MemberLookup_FindMembers): Use `builder_to_declspace' if the type is
 299         a dynamic type and TypeHandle.GetTypeHandle() otherwise.
 300
 301 2002-08-16  Martin Baulig  <martin@gnome.org>
 302
 303         * typemanager.cs (ICachingMemberFinder): Removed.
 304         (IMemberFinder.MemberCache): New property.
 305         (TypeManager.FindMembers): Merged this with RealFindMembers().
 306         This function will never be called from TypeManager.MemberLookup()
 307         so we can't use the cache here, just the IMemberFinder.
 308         (TypeManager.MemberLookup_FindMembers): Check whether the
 309         IMemberFinder has a MemberCache and call the cache's FindMembers
 310         function.
 311         (MemberCache): Rewrote larger parts of this yet another time and
 312         cleaned it up a bit.
 313
 314 2002-08-15  Miguel de Icaza  <miguel@ximian.com>
 315
 316         * driver.cs (LoadArgs): Support quoting.
 317
 318         (Usage): Show the CSC-like command line arguments.
 319
 320         Improved a few error messages.
 321
 322 2002-08-15  Martin Baulig  <martin@gnome.org>
 323
 324         * typemanager.cs (IMemberContainer.Type): New property.
 325         (IMemberContainer.IsInterface): New property.
 326
 327         The following changes are conditional to BROKEN_RUNTIME, which is
 328         defined at the top of the file.
 329
 330         * typemanager.cs (MemberCache.MemberCache): Don't add the base
 331         class'es members, but add all members from TypeHandle.ObjectType
 332         if we're an interface.
 333         (MemberCache.AddMembers): Set the Declared flag if member.DeclaringType
 334         is the current type.
 335         (MemberCache.CacheEntry.Container): Removed this field.
 336         (TypeHandle.GetMembers): Include inherited members.
 337
 338 2002-08-14  Gonzalo Paniagua Javier <gonzalo@ximian.com>
 339
 340         * typemanager.cs: fixed compilation and added a comment on a field that
 341         is never used.
 342
 343 2002-08-15  Martin Baulig  <martin@gnome.org>
 344
 345         * class.cs (ConstructorInitializer.Resolve): In the
 346         Expression.MemberLookup call, use the queried_type as
 347         invocation_type.
 348
 349         * typemanager.cs (IMemberContainer.GetMembers): Removed the `bool
 350         declared' attribute, it's always true.
 351         (IMemberContainer.Parent, IMemberContainer.Name): New properties.
 352         (TypeManager.MemberLookup_FindMembers): [FIXME FIXME FIXME] Added
 353         temporary wrapper for FindMembers which tells MemberLookup whether
 354         members from the base classes are included in the return value.
 355         This will go away soon.
 356         (TypeManager.MemberLookup): Use this temporary hack here; once the
 357         new MemberCache is completed, we don't need to do the DeclaredOnly
 358         looping here anymore since the MemberCache will take care of this.
 359         (TypeManager.IsSubclassOrNestedChildOf): Allow `type == parent'.
 360         (MemberCache): When creating the MemberCache for a class, get
 361         members from the current class and all its base classes.
 362         (MemberCache.CacheEntry.Container): New field.  This is a
 363         temporary hack until the Mono runtime is fixed to distinguish
 364         between ReflectedType and DeclaringType.  It allows us to use MCS
 365         with both the MS runtime and the unfixed Mono runtime without
 366         problems and without accecting performance.
 367         (MemberCache.SearchMembers): The DeclaredOnly looping from
 368         TypeManager.MemberLookup is now done here.
 369
 370 2002-08-14  Martin Baulig  <martin@gnome.org>
 371
 372         * statement.cs (MyStructInfo.MyStructInfo): Don't call
 373         Type.GetFields on dynamic types but get the fields from the
 374         corresponding TypeContainer.
 375         (MyStructInfo.GetStructInfo): Added check for enum types.
 376
 377         * typemanager.cs (MemberList.IsSynchronized): Implemented.
 378         (MemberList.SyncRoot): Implemented.
 379         (TypeManager.FilterWithClosure): No need to check permissions if
 380         closure_start_type == closure_invocation_type, don't crash if
 381         closure_invocation_type is null.
 382
 383 2002-08-13  Martin Baulig  <martin@gnome.org>
 384
 385         Rewrote TypeContainer.FindMembers to use a member cache.  This
 386         gives us a speed increase of about 35% for the self-hosting MCS
 387         build and of about 15-20% for the class libs (both on GNU/Linux).
 388
 389         * report.cs (Timer): New class to get enhanced profiling.  This
 390         whole class is "TIMER" conditional since it remarkably slows down
 391         compilation speed.
 392
 393         * class.cs (MemberList): New class.  This is an IList wrapper
 394         which we're now using instead of passing MemberInfo[]'s around to
 395         avoid copying this array unnecessarily.
 396         (IMemberFinder.FindMember): Return a MemberList, not a MemberInfo [].
 397         (ICachingMemberFinder, IMemberContainer): New interface.
 398         (TypeManager.FilterWithClosure): If `criteria' is null, the name
 399         has already been checked, otherwise use it for the name comparision.
 400         (TypeManager.FindMembers): Renamed to RealMemberFinder and
 401         provided wrapper which tries to use ICachingMemberFinder.FindMembers
 402         if possible.  Returns a MemberList, not a MemberInfo [].
 403         (TypeHandle): New class, implements IMemberContainer.  We create
 404         one instance of this class per type, it contains a MemberCache
 405         which is used to do the member lookups.
 406         (MemberCache): New class.  Each instance of this class contains
 407         all members of a type and a name-based hash table.
 408         (MemberCache.FindMembers): This is our new member lookup
 409         function.  First, it looks up all members of the requested name in
 410         the hash table.  Then, it walks this list and sorts out all
 411         applicable members and returns them.
 412
 413 2002-08-13  Martin Baulig  <martin@gnome.org>
 414
 415         In addition to a nice code cleanup, this gives us a performance
 416         increase of about 1.4% on GNU/Linux - not much, but it's already
 417         half a second for the self-hosting MCS compilation.
 418
 419         * typemanager.cs (IMemberFinder): New interface.  It is used by
 420         TypeManager.FindMembers to call FindMembers on a TypeContainer,
 421         Enum, Delegate or Interface.
 422         (TypeManager.finder_to_member_finder): New PtrHashtable.
 423         (TypeManager.finder_to_container): Removed.
 424         (TypeManager.finder_to_delegate): Removed.
 425         (TypeManager.finder_to_interface): Removed.
 426         (TypeManager.finder_to_enum): Removed.
 427
 428         * interface.cs (Interface): Implement IMemberFinder.
 429
 430         * delegate.cs (Delegate): Implement IMemberFinder.
 431
 432         * enum.cs (Enum): Implement IMemberFinder.
 433
 434         * class.cs (TypeContainer): Implement IMemberFinder.
 435
 436 2002-08-12  Martin Baulig  <martin@gnome.org>
 437
 438         * ecore.cs (TypeExpr.DoResolveType): Mark this as virtual.
 439
 440 2002-08-12  Martin Baulig  <martin@gnome.org>
 441
 442         * ecore.cs (ITypeExpression): New interface for expressions which
 443         resolve to a type.
 444         (TypeExpression): Renamed to TypeLookupExpression.
 445         (Expression.DoResolve): If we're doing a types-only lookup, the
 446         expression must implement the ITypeExpression interface and we
 447         call DoResolveType() on it.
 448         (SimpleName): Implement the new ITypeExpression interface.
 449         (SimpleName.SimpleNameResolve): Removed the ec.OnlyLookupTypes
 450         hack, the situation that we're only looking up types can't happen
 451         anymore when this method is called.  Moved the type lookup code to
 452         DoResolveType() and call it.
 453         (SimpleName.DoResolveType): This ITypeExpression interface method
 454         is now doing the types-only lookup.
 455         (TypeExpr, TypeLookupExpression): Implement ITypeExpression.
 456         (ResolveFlags): Added MaskExprClass.
 457
 458         * expression.cs (MemberAccess): Implement the ITypeExpression
 459         interface.
 460         (MemberAccess.DoResolve): Added support for a types-only lookup
 461         when we're called via ITypeExpression.DoResolveType().
 462         (ComposedCast): Implement the ITypeExpression interface.
 463
 464         * codegen.cs (EmitContext.OnlyLookupTypes): Removed.  Call
 465         Expression.Resolve() with ResolveFlags.Type instead.
 466
 467 2002-08-12  Martin Baulig  <martin@gnome.org>
 468
 469         * interface.cs (Interface.Define): Apply attributes.
 470
 471         * attribute.cs (Attribute.ApplyAttributes): Added support for
 472         interface attributes.
 473
 474 2002-08-11  Martin Baulig  <martin@gnome.org>
 475
 476         * statement.cs (Block.Emit): Only check the "this" variable if we
 477         do not always throw an exception.
 478
 479         * ecore.cs (PropertyExpr.DoResolveLValue): Implemented, check
 480         whether the property has a set accessor.
 481
 482 2002-08-11  Martin Baulig  <martin@gnome.org>
 483
 484         Added control flow analysis support for structs.
 485
 486         * ecore.cs (ResolveFlags): Added `DisableFlowAnalysis' to resolve
 487         with control flow analysis turned off.
 488         (IVariable): New interface.
 489         (SimpleName.SimpleNameResolve): If MemberAccess.ResolveMemberAccess
 490         returns an IMemberExpr, call DoResolve/DoResolveLValue on it.
 491         (FieldExpr.DoResolve): Resolve the instance expression with flow
 492         analysis turned off and do the definite assignment check after the
 493         resolving when we know what the expression will resolve to.
 494
 495         * expression.cs (LocalVariableReference, ParameterReference):
 496         Implement the new IVariable interface, only call the flow analysis
 497         code if ec.DoFlowAnalysis is true.
 498         (This): Added constructor which takes a Block argument.  Implement
 499         the new IVariable interface.
 500         (MemberAccess.DoResolve, MemberAccess.DoResolveLValue): Call
 501         DoResolve/DoResolveLValue on the result of ResolveMemberLookup().
 502         This does the definite assignment checks for struct members.
 503
 504         * class.cs (Constructor.Emit): If this is a non-static `struct'
 505         constructor which doesn't have any initializer, call
 506         Block.AddThisVariable() to tell the flow analysis code that all
 507         struct elements must be initialized before control returns from
 508         the constructor.
 509
 510         * statement.cs (MyStructInfo): New public class.
 511         (UsageVector.this [VariableInfo vi]): Added `int field_idx'
 512         argument to this indexer.  If non-zero, check an individual struct
 513         member, not the whole struct.
 514         (FlowBranching.CheckOutParameters): Check struct members.
 515         (FlowBranching.IsVariableAssigned, SetVariableAssigned): Added
 516         overloaded versions of these methods which take an additional
 517         `int field_idx' argument to check struct members.
 518         (FlowBranching.IsParameterAssigned, SetParameterAssigned): Added
 519         overloaded versions of these methods which take an additional
 520         `string field_name' argument to check struct member.s
 521         (VariableInfo): Implement the IVariable interface.
 522         (VariableInfo.StructInfo): New public property.  Returns the
 523         MyStructInfo instance of the variable if it's a struct or null.
 524         (Block.AddThisVariable): New public method.  This is called from
 525         Constructor.Emit() for non-static `struct' constructor which do
 526         not have any initializer.  It creates a special variable for the
 527         "this" instance variable which will be checked by the flow
 528         analysis code to ensure that all of the struct's fields are
 529         initialized before control returns from the constructor.
 530         (UsageVector): Added support for struct members.  If a
 531         variable/parameter is a struct with N members, we reserve a slot
 532         in the usage vector for each member.  A struct is considered fully
 533         initialized if either the struct itself (slot 0) or all its
 534         members are initialized.
 535
 536 2002-08-08  Martin Baulig  <martin@gnome.org>
 537
 538         * driver.cs (Driver.MainDriver): Only report an error CS5001
 539         if there were no compilation errors.
 540
 541         * codegen.cs (EmitContext.EmitContext): Use the DeclSpace's
 542         `UnsafeContext' property to determine whether the parent is in
 543         unsafe context rather than checking the parent's ModFlags:
 544         classes nested in an unsafe class are unsafe as well.
 545
 546 2002-08-08  Martin Baulig  <martin@gnome.org>
 547
 548         * statement.cs (UsageVector.MergeChildren): Distinguish between
 549         `Breaks' and `Returns' everywhere, don't set `Breaks' anymore if
 550         we return.  Added test17() and test18() to test-154.cs.
 551
 552 2002-08-08  Martin Baulig  <martin@gnome.org>
 553
 554         * typemanager.cs (TypeManager.FilterWithClosure): If we have
 555         Family access, make sure the invoking type isn't a subclass of the
 556         queried type (that'd be a CS1540).
 557
 558         * ecore.cs (Expression.MemberLookup): Added overloaded version of
 559         this method which takes an additional `Type invocation_type'.
 560
 561         * expression.cs (BaseAccess.DoResolve): Use the base type as
 562         invocation and query type.
 563         (MemberAccess.DoResolve): If the lookup failed and we're about to
 564         report a CS0122, try a lookup with the ec.ContainerType - if this
 565         succeeds, we must report a CS1540.
 566
 567 2002-08-08  Martin Baulig  <martin@gnome.org>
 568
 569         * ecore.cs (IMemberExpr): Added `bool IsInstance' property.
 570         (MethodGroupExpr): Implement the IMemberExpr interface.
 571
 572         * expression (MemberAccess.ResolveMemberAccess): No need to have
 573         any special code for MethodGroupExprs anymore, they're now
 574         IMemberExprs.
 575
 576 2002-08-08  Martin Baulig  <martin@gnome.org>
 577
 578         * typemanager.cs (TypeManager.FilterWithClosure): Check Assembly,
 579         Family, FamANDAssem and FamORAssem permissions.
 580         (TypeManager.IsSubclassOrNestedChildOf): New public method.
 581
 582 2002-08-08  Martin Baulig  <martin@gnome.org>
 583
 584         * statement.cs (FlowBranchingType): Added LOOP_BLOCK.
 585         (UsageVector.MergeChildren): `break' breaks unless we're in a switch
 586         or loop block.
 587
 588 Thu Aug 8 10:28:07 CEST 2002 Paolo Molaro <lupus@ximian.com>
 589
 590         * driver.cs: implemented /resource option to embed managed resources.
 591
 592 2002-08-07  Martin Baulig  <martin@gnome.org>
 593
 594         * class.cs (FieldBase.Initializer): Renamed to `init' and made private.
 595         (FieldBase.HasFieldInitializer): New public property.
 596         (FieldBase.GetInitializerExpression): New public method.  Resolves and
 597         returns the field initializer and makes sure it is only resolved once.
 598         (TypeContainer.EmitFieldInitializers): Call
 599         FieldBase.GetInitializerExpression to get the initializer, this ensures
 600         that it isn't resolved multiple times.
 601
 602         * codegen.cs (EmitContext): Added `bool IsFieldInitialier'.  This tells
 603         the resolving process (SimpleName/MemberLookup) that we're currently
 604         emitting a field initializer (which must not access any instance members,
 605         this is an error CS0236).
 606
 607         * ecore.cs (SimpleName.Error_ObjectRefRequired): Added EmitContext
 608         argument, if the `IsFieldInitializer' flag is set, we must report and
 609         error CS0236 and not an error CS0120.
 610
 611 2002-08-07  Martin Baulig  <martin@gnome.org>
 612
 613         * ecore.cs (IMemberExpr): New public interface.
 614         (FieldExpr, PropertyExpr, EventExpr): Implement IMemberExpr.
 615         (SimpleName.SimpleNameResolve): Call MemberAccess.ResolveMemberAccess
 616         if the expression is an IMemberExpr.
 617
 618         * expression.cs (MemberAccess.ResolveMemberAccess): Allow `left'
 619         to be null, implicitly default to `this' if we're non-static in
 620         this case.  Simplified the code a lot by using the new IMemberExpr
 621         interface.  Also fixed bug #28176 here.
 622
 623 2002-08-06  Martin Baulig  <martin@gnome.org>
 624
 625         * cs-parser.jay (SimpleLookup): Removed.  We need to create
 626         ParameterReferences during semantic analysis so that we can do a
 627         type-only search when resolving Cast, TypeOf and SizeOf.
 628         (block): Pass the `current_local_parameters' to the Block's
 629         constructor.
 630
 631         * class.cs (ConstructorInitializer): Added `Parameters parameters'
 632         argument to the constructor.
 633         (ConstructorInitializer.Resolve): Create a temporary implicit
 634         block with the parameters.
 635
 636         * ecore.cs (SimpleName.SimpleNameResolve): Resolve parameter
 637         references here if we aren't doing a type-only search.
 638
 639         * statement.cs (Block): Added constructor which takes a
 640         `Parameters parameters' argument.
 641         (Block.Parameters): New public property.
 642
 643         * support.cs (InternalParameters.Parameters): Renamed `parameters'
 644         to `Parameters' and made it public readonly.
 645
 646 2002-08-06  Martin Baulig  <martin@gnome.org>
 647
 648         * ecore.cs (Expression.Warning): Made this public as well.
 649
 650         * report.cs (Report.Debug): Print the contents of collections.
 651
 652 2002-08-06  Martin Baulig  <martin@gnome.org>
 653
 654         * ecore.cs (Expression.ResolveFlags): New [Flags] enum.  This is
 655         used to tell Resolve() which kinds of expressions it may return.
 656         (Expression.Resolve): Added overloaded version of this method which
 657         takes a `ResolveFlags flags' argument.  This can be used to tell
 658         Resolve() which kinds of expressions it may return.  Reports a
 659         CS0118 on error.
 660         (Expression.ResolveWithSimpleName): Removed, use Resolve() with
 661         ResolveFlags.SimpleName.
 662         (Expression.Error118): Added overloaded version of this method which
 663         takes a `ResolveFlags flags' argument.  It uses the flags to determine
 664         which kinds of expressions are allowed.
 665
 666         * expression.cs (Argument.ResolveMethodGroup): New public method.
 667         Resolves an argument, but allows a MethodGroup to be returned.
 668         This is used when invoking a delegate.
 669
 670         * TODO: Updated a bit.
 671
 672 2002-08-06  Gonzalo Paniagua Javier <gonzalo@ximian.com>
 673
 674         Fixed compilation with csc.
 675
 676         * ecore.cs: Expression.Error made public. Is this correct? Should
 677         Warning be made public too?
 678
 679         * expression.cs: use ea.Location instead of ea.loc.
 680         [FIXME:  Filed as bug #28607: MCS must report these errors.]
 681
 682 2002-08-06  Martin Baulig  <martin@gnome.org>
 683
 684         * ecore.cs (Expression.loc): Moved the location here instead of
 685         duplicating it in all derived classes.
 686         (Expression.Location): New public property.
 687         (Expression.Error, Expression.Warning): Made them non-static and
 688         removed the location argument.
 689         (Expression.Warning): Added overloaded version which takes an
 690         `int level' argument.
 691         (Expression.Error118): Make this non-static and removed the
 692         expression and location arguments.
 693         (TypeExpr): Added location argument to the constructor.
 694
 695         * expression.cs (StaticCallExpr): Added location argument to
 696         the constructor.
 697         (Indirection, PointerArithmetic): Likewise.
 698         (CheckedExpr, UnCheckedExpr): Likewise.
 699         (ArrayAccess, IndexerAccess, UserCast, ArrayPtr): Likewise.
 700         (StringPtr): Likewise.
 701
 702
 703 2002-08-05  Martin Baulig  <martin@gnome.org>
 704
 705         * expression.cs (BaseAccess.DoResolve): Actually report errors.
 706
 707         * assign.cs (Assign.DoResolve): Check whether the source
 708         expression is a value or variable.
 709
 710         * statement.cs (Try.Resolve): Set ec.InTry/InCatch/InFinally
 711         while resolving the corresponding blocks.
 712
 713         * interface.cs (Interface.GetInterfaceTypeByName): Actually report
 714         an error, don't silently return null.
 715
 716         * statement.cs (Block.AddVariable): Do the error reporting here
 717         and distinguish between CS0128 and CS0136.
 718         (Block.DoResolve): Report all unused labels (warning CS0164).
 719         (LabeledStatement): Pass the location to the constructor.
 720         (LabeledStatement.HasBeenReferenced): New property.
 721         (LabeledStatement.Resolve): Set it to true here.
 722
 723         * statement.cs (Return.Emit): Return success even after reporting
 724         a type mismatch error (CS0126 or CS0127), this is what csc does and
 725         it avoids confusing the users with any consecutive errors.
 726
 727 2002-08-05  Martin Baulig  <martin@gnome.org>
 728
 729         * enum.cs (Enum.LookupEnumValue): Catch circular definitions.
 730
 731         * const.cs (Const.LookupConstantValue): Catch circular definitions.
 732
 733         * expression.cs (MemberAccess.DoResolve): Silently return if an
 734         error has already been reported.
 735
 736         * ecore.cs (Expression.MemberLookupFinal): Silently return if an
 737         error has already been reported.
 738
 739 2002-08-05  Martin Baulig  <martin@gnome.org>
 740
 741         * statement.cs (UsageVector): Only initialize the `parameters'
 742         vector if we actually have any "out" parameters.
 743
 744 2002-08-05  Martin Baulig  <martin@gnome.org>
 745
 746         * expression.cs (Binary.ResolveOperator): When combining delegates,
 747         they must have the same type.
 748
 749 2002-08-05  Martin Baulig  <martin@gnome.org>
 750
 751         * typemanager.cs (TypeManager.GetArgumentTypes): Don't call
 752         PropertyInfo.GetIndexParameters() on dynamic types, this doesn't
 753         work with the ms runtime and we also don't need it: if we're a
 754         PropertyBuilder and not in the `indexer_arguments' hash, then we
 755         are a property and not an indexer.
 756
 757         * class.cs (TypeContainer.AsAccessible): Use Type.IsArray,
 758         Type.IsPointer and Type.IsByRef instead of Type.HasElementType
 759         since the latter one doesn't work with the ms runtime.
 760
 761 2002-08-03  Martin Baulig  <martin@gnome.org>
 762
 763         Fixed bugs #27998 and #22735.
 764
 765         * class.cs (Method.IsOperator): New public field.
 766         (Method.CheckBase): Report CS0111 if there's already a method
 767         with the same parameters in the current class.  Report CS0508 when
 768         attempting to change the return type of an inherited method.
 769         (MethodData.Emit): Report CS0179 if a method doesn't have a body
 770         and it's not marked abstract or extern.
 771         (PropertyBase): New abstract base class for Property and Indexer.
 772         (PropertyBase.CheckBase): Moved here from Property and made it work
 773         for indexers.
 774         (PropertyBase.Emit): Moved here from Property.Emit, Indexer.Emit is
 775         the same so we can reuse it there.
 776         (Property, Indexer): Derive from PropertyBase.
 777         (MethodSignature.inheritable_property_signature_filter): New delegate
 778         to find properties and indexers.
 779
 780         * decl.cs (MemberCore.CheckMethodAgainstBase): Added `string name'
 781         argument and improved error reporting.
 782
 783         * parameter.cs (Parameters.GetEmptyReadOnlyParameters): Renamed to
 784         EmptyReadOnlyParameters and made it a property.
 785
 786         * typemanager.cs (TypeManager.GetArgumentTypes): Added overloaded
 787         version of this method which takes a `PropertyInfo indexer'.
 788         (TypeManager.RegisterIndexer): New method.
 789
 790         * class.cs: Added myself as author of this file :-)
 791
 792 2002-08-03  Gonzalo Paniagua Javier <gonzalo@ximian.com>
 793
 794         * class.cs: fixed compilation on windoze.
 795
 796 2002-08-03  Martin Baulig  <martin@gnome.org>
 797
 798         * interface.cs (Interface.GetInterfaceBases): Check whether all
 799         base interfaces are at least as accessible than the current one.
 800
 801         * class.cs (TypeContainer.GetClassBases): Check whether base types
 802         are at least as accessible than the current type.
 803         (TypeContainer.AsAccessible): Implemented and made non-static.
 804         (MemberBase.CheckParameters): Report errors if the accessibility
 805         checks fail.
 806
 807         * delegate.cs (Delegate.Delegate): The default visibility is
 808         internal for top-level types and private for nested types.
 809         (Delegate.Define): Report errors if the accessibility checks fail.
 810
 811         * enum.cs (Enum.Enum): The default visibility is internal for
 812         top-level types and private for nested types.
 813         (Enum.DefineType): Compute the correct visibility.
 814
 815         * modifiers.cs (Modifiers.TypeAttr): Added a version of this
 816         function which takes a `bool is_toplevel' instead of a TypeContainer.
 817
 818         * typemanager.cs (TypeManager.IsBuiltinType): `void' is also a
 819         builtin type.
 820
 821 2002-08-02  Martin Baulig  <martin@gnome.org>
 822
 823         * expression.cs (LocalVariableReferenc): Added constructor which
 824         takes additional `VariableInfo vi' and `bool is_readonly' arguments.
 825         (LocalVariableReference.IsReadOnly): New property.
 826         (LocalVariableReference.DoResolveLValue): Report a CS1604 if the
 827         variable is readonly, use our own readonly flag to do this; you can
 828         use the new constructor to get a writable reference to a read-only
 829         variable.
 830
 831         * cs-parser.jay (foreach_statement, using_statement): Get a writable
 832         reference to the local variable.
 833
 834 2002-08-01  Miguel de Icaza  <miguel@ximian.com>
 835
 836         * rootcontext.cs (ResolveCore): Also include System.Exception
 837
 838         * statement.cs (Block.Emit): Do not emit the dead-code warnings if
 839         we reach an EmptyStatement.
 840
 841         (Catch.DoResolve, Throw.DoResolve): Throwing the System.Exception
 842         is also fine.
 843
 844         * expression.cs (Binary.ResolveOperator): Check error result in
 845         two places.
 846
 847         use brtrue/brfalse directly and avoid compares to null.
 848
 849 2002-08-02  Martin Baulig  <martin@gnome.org>
 850
 851         * class.cs (TypeContainer.Define): Define all nested interfaces here.
 852         Fixes bug #28407, added test-155.cs.
 853
 854 2002-08-01  Martin Baulig  <martin@gnome.org>
 855
 856         * class.cs (Event.EmitDefaultMethod): Make this work with static
 857         events.  Fixes #28311, added verify-3.cs.
 858
 859 2002-08-01  Martin Baulig  <martin@gnome.org>
 860
 861         * statement.cs (ForeachHelperMethods): Added `enumerator_type' and
 862         `is_disposable' fields.
 863         (Foreach.GetEnumeratorFilter): Set `hm.enumerator_type' and
 864         `hm.is_disposable' if we're using the collection pattern.
 865         (Foreach.EmitCollectionForeach): Use the correct type for the
 866         enumerator's local variable, only emit the try/finally block if
 867         necessary (fixes #27713).
 868
 869 2002-08-01  Martin Baulig  <martin@gnome.org>
 870
 871         * ecore.cs (Expression.report118): Renamed to Error118 and made
 872         it public static.
 873
 874         * statement.cs (Throw.Resolve): Check whether the expression is of
 875         the correct type (CS0118) and whether the type derives from
 876         System.Exception (CS0155).
 877         (Catch.Resolve): New method.  Do the type lookup here and check
 878         whether it derives from System.Exception (CS0155).
 879         (Catch.CatchType, Catch.IsGeneral): New public properties.
 880
 881         * typemanager.cs (TypeManager.exception_type): Added.
 882
 883 2002-07-31  Miguel de Icaza  <miguel@ximian.com>
 884
 885         * driver.cs: Updated About function.
 886
 887 2002-07-31  Martin Baulig  <martin@gnome.org>
 888
 889         Implemented Control Flow Analysis.
 890
 891         * codegen.cs (EmitContext.DoFlowAnalysis): New public variable.
 892         (EmitContext.CurrentBranching): Added.
 893         (EmitContext.StartFlowBranching): Added.
 894         (EmitContext.EndFlowBranching): Added.
 895         (EmitContext.KillFlowBranching): Added.
 896         (EmitContext.IsVariableAssigned): Added.
 897         (EmitContext.SetVariableAssigned): Added.
 898         (EmitContext.IsParameterAssigned): Added.
 899         (EmitContext.SetParameterAssigned): Added.
 900         (EmitContext.EmitTopBlock): Added `InternalParameters ip' argument.
 901         Added control flow analysis stuff here.
 902
 903         * expression.cs (Unary.DoResolve): If the operator is Oper.AddressOf,
 904         resolve the expression as lvalue.
 905         (LocalVariableReference.DoResolve): Check whether the variable has
 906         already been assigned.
 907         (ParameterReference.DoResolveLValue): Override lvalue resolve to mark
 908         the parameter as assigned here.
 909         (ParameterReference.DoResolve): Check whether the parameter has already
 910         been assigned.
 911         (Argument.Resolve): If it's a `ref' or `out' argument, resolve the
 912         expression as lvalue.
 913
 914         * statement.cs (FlowBranching): New class for the flow analysis code.
 915         (Goto): Resolve the label in Resolve, not in Emit; added flow analysis.
 916         (LabeledStatement.IsDefined): New public property.
 917         (LabeledStatement.AddUsageVector): New public method to tell flow
 918         analyis that the label may be reached via a forward jump.
 919         (GotoCase): Lookup and resolve the label in Resolve, not in Emit; added
 920         flow analysis.
 921         (VariableInfo.Number): New public field.  This is used by flow analysis
 922         to number all locals of a block.
 923         (Block.CountVariables): New public property.  This is the number of
 924         local variables in this block (including the locals from all parent
 925         blocks).
 926         (Block.EmitMeta): Number all the variables.
 927
 928         * statement.cs: Added flow analysis support to all classes.
 929
 930 2002-07-31  Martin Baulig  <martin@gnome.org>
 931
 932         * driver.cs: Added "--mcs-debug" argument if MCS_DEBUG is defined.
 933         To get debugging messages, compile mcs with /define:MCS_DEBUG and
 934         then use this argument.
 935
 936         * report.cs (Report.Debug): Renamed to conditional to "MCS_DEBUG".
 937
 938         * makefile.gnu (MCS_FLAGS): Include $(MCS_DEFINES), the user may
 939         use this to specify /define options.
 940
 941 2002-07-29  Martin Baulig  <martin@gnome.org>
 942
 943         * statement.cs (Fixed): Moved all code that does variable lookups
 944         and resolvings from Emit to Resolve.
 945
 946         * statement.cs (For): Moved all code that does variable lookups
 947         and resolvings from Emit to Resolve.
 948
 949         * statement.cs (Using): Moved all code that does variable lookups
 950         and resolvings from Emit to Resolve.
 951
 952 2002-07-29  Martin Baulig  <martin@gnome.org>
 953
 954         * attribute.cs (Attribute.Resolve): Explicitly catch a
 955         System.NullReferenceException when creating the
 956         CustromAttributeBuilder and report a different warning message.
 957
 958 2002-07-29  Martin Baulig  <martin@gnome.org>
 959
 960         * support.cs (ParameterData.ParameterName): Added method to
 961         get the name of a parameter.
 962
 963         * typemanager.cs (TypeManager.IsValueType): New public method.
 964
 965 2002-07-29  Martin Baulig  <martin@gnome.org>
 966
 967         * parameter.cs (Parameter.Modifier): Added `ISBYREF = 8'.  This
 968         is a flag which specifies that it's either ref or out.
 969         (Parameter.GetParameterInfo (DeclSpace, int, out bool)): Changed
 970         the out parameter to `out Parameter.Modifier mod', also set the
 971         Parameter.Modifier.ISBYREF flag on it if it's either ref or out.
 972
 973         * support.cs (InternalParameters.ParameterModifier): Distinguish
 974         between Parameter.Modifier.OUT and Parameter.Modifier.REF, set the
 975         Parameter.Modifier.ISBYREF flag if it's either ref or out.
 976
 977         * expression.cs (Argument.GetParameterModifier): Distinguish
 978         between Parameter.Modifier.OUT and Parameter.Modifier.REF, set the
 979         Parameter.Modifier.ISBYREF flag if it's either ref or out.
 980
 981 2002-07-29  Martin Baulig  <martin@gnome.org>
 982
 983         * expression.cs (ParameterReference.ParameterReference): Added
 984         `Location loc' argument to the constructor.
 985
 986         * cs-parser.jay: Pass location to ParameterReference.
 987
 988 2002-07-28  Miguel de Icaza  <miguel@ximian.com>
 989
 990         * statement.cs (Try): Initialize the location.
 991
 992         * cs-parser.jay: pass location to Try.
 993
 994         * expression.cs (Unary.Reduce): Change the prototype to return
 995         whether a constant fold could be performed or not.  The result is
 996         returned in an out parameters.  In the case of Indirection and
 997         AddressOf, we want to perform the full tests.
 998
 999 2002-07-26  Miguel de Icaza  <miguel@ximian.com>
1000
1001         * statement.cs (Statement.Emit): Flag dead code.
1002
1003 2002-07-27  Andrew Birkett  <andy@nobugs.org>
1004
1005         * expression.cs (Unary.Reduce): Handle AddressOf and Indirection.
1006
1007 2002-07-27  Martin Baulig  <martin@gnome.org>
1008
1009         * class.cs (MethodData.Define): Put back call to
1010         TypeManager.AddMethod(), accidentally commented this out.
1011
1012         * report.cs (Debug): New public method to print debugging information,
1013         this is `[Conditional ("DEBUG")]'.
1014
1015 2002-07-26  Martin Baulig  <martin@gnome.org>
1016
1017         * cs-parser.jay (CSharpParser): Added `Stack switch_stack'.
1018         (switch_statement): Push the current_block to the switch_stack and
1019         pop it again when we're done with the switch.
1020         (switch_section): The new block is a child of the current_block.
1021         Fixes bug #24007, added test-152.cs.
1022
1023 2002-07-27  Martin Baulig  <martin@gnome.org>
1024
1025         * expression.cs (Invocation.EmitArguments): When calling a varargs
1026         function with only its fixed arguments, we need to pass an empty
1027         array.
1028
1029 2002-07-27  Martin Baulig  <martin@gnome.org>
1030
1031         Mono 0.13 has been released.
1032
1033 2002-07-25  Miguel de Icaza  <miguel@ximian.com>
1034
1035         * driver.cs: Rename --resource to --linkres, because that is what
1036         we do currently, we dont support --resource yet.
1037
1038         * cs-tokenizer.cs: Fix test for reporting endif mismatches.
1039
1040 2002-07-25  Martin Baulig  <martin@gnome.org>
1041
1042         * class.cs (MethodData): New public class.  This is a `method builder'
1043         class for a method or one accessor of a Property/Indexer/Event.
1044         (MethodData.GetMethodFlags): Moved here from MemberBase.
1045         (MethodData.ApplyAttributes): Likewise.
1046         (MethodData.ApplyObsoleteAttribute): Likewise.
1047         (MethodData.ApplyConditionalAttribute): Likewise.
1048         (MethodData.ApplyDllImportAttribute): Likewise.
1049         (MethodData.CheckAbstractAndExternal): Likewise.
1050         (MethodData.Define): Formerly knows as MemberBase.DefineMethod().
1051         (MethodData.Emit): Formerly known as Method.Emit().
1052         (MemberBase): Moved everything which was specific to a single
1053         accessor/method to MethodData.
1054         (Method): Create a new MethodData and call Define() and Emit() on it.
1055         (Property, Indexer, Event): Create a new MethodData objects for each
1056         accessor and call Define() and Emit() on them.
1057
1058 2002-07-25  Martin Baulig  <martin@gnome.org>
1059
1060         Made MethodCore derive from MemberBase to reuse the code from there.
1061         MemberBase now also checks for attributes.
1062
1063         * class.cs (MethodCore): Derive from MemberBase, not MemberCore.
1064         (MemberBase.GetMethodFlags): Moved here from class Method and marked
1065         as virtual.
1066         (MemberBase.DefineAccessor): Renamed to DefineMethod(), added
1067         `CallingConventions cc' and `Attributes opt_attrs' arguments.
1068         (MemberBase.ApplyAttributes): New virtual method; applies the
1069         attributes to a method or accessor.
1070         (MemberBase.ApplyObsoleteAttribute): New protected virtual method.
1071         (MemberBase.ApplyConditionalAttribute): Likewise.
1072         (MemberBase.ApplyDllImportAttribute): Likewise.
1073         (MemberBase.CheckAbstractAndExternal): Likewise.
1074         (MethodCore.ParameterTypes): This is now a property instead of a
1075         method, it's initialized from DoDefineParameters().
1076         (MethodCore.ParameterInfo): Removed the set accessor.
1077         (MethodCore.DoDefineParameters): New protected virtual method to
1078         initialize ParameterTypes and ParameterInfo.
1079         (Method.GetReturnType): We can now simply return the MemberType.
1080         (Method.GetMethodFlags): Override the MemberBase version and add
1081         the conditional flags.
1082         (Method.CheckBase): Moved some code from Define() here, call
1083         DoDefineParameters() here.
1084         (Method.Define): Use DoDefine() and DefineMethod() from MemberBase
1085         here to avoid some larger code duplication.
1086         (Property.Emit, Indexer.Emit): Call CheckAbstractAndExternal() to
1087         ensure that abstract and external accessors don't declare a body.
1088
1089         * attribute.cs (Attribute.GetValidPieces): Make this actually work:
1090         `System.Attribute.GetCustomAttributes (attr.Type)' does a recursive
1091         lookup in the attribute's parent classes, so we need to abort as soon
1092         as we found the first match.
1093         (Attribute.Obsolete_GetObsoleteMessage): Return the empty string if
1094         the attribute has no arguments.
1095
1096         * typemanager.cs (TypeManager.AddMethod): Now takes a MemberBase instead
1097         of a Method.
1098
1099 2002-07-24  Gonzalo Paniagua Javier <gonzalo@ximian.com>
1100
1101         * cs-parser.jay: reverted previous patch.
1102
1103 2002-07-24  Gonzalo Paniagua Javier <gonzalo@ximian.com>
1104
1105         * cs-parser.jay: fixed bug #22119.
1106
1107 2002-07-24  Gonzalo Paniagua Javier <gonzalo@ximian.com>
1108
1109         * attribute.cs: fixed compilation. The error was:
1110         "attribute.cs(571,17): error CS0177: The out parameter 'is_error' must
1111         be assigned to before control leaves the current method."
1112         [FIXME:  Filed as bug #28186: MCS must report this error.]
1113
1114 2002-07-25  Martin Baulig  <martin@gnome.org>
1115
1116         * attribute.cs (Attribute.Conditional_GetConditionName): New static
1117         method to pull the condition name ouf of a Conditional attribute.
1118         (Attribute.Obsolete_GetObsoleteMessage): New static method to pull
1119         the obsolete message and error flag out of an Obsolete attribute.
1120
1121         * class.cs (Method.GetMethodFlags): New public method to get the
1122         TypeManager.MethodFlags for this method.
1123         (Method.ApplyConditionalAttribute, Method.ApplyObsoleteAttribute): New
1124         private methods.
1125         (Method.Define): Get and apply the Obsolete and Conditional attributes;
1126         if we're overriding a virtual function, set the new private variable
1127         `parent_method'; call the new TypeManager.AddMethod().
1128
1129         * typemanager.cs (TypeManager.AddMethod): New static method.  Stores
1130         the MethodBuilder and the Method in a PtrHashtable.
1131         (TypeManager.builder_to_method): Added for this purpose.
1132         (TypeManager.MethodFlags): Added IsObsoleteError.
1133         (TypeManager.GetMethodFlags): Added `Location loc' argument.  Lookup
1134         Obsolete and Conditional arguments in MethodBuilders.  If we discover
1135         an Obsolete attribute, emit an appropriate warning 618 / error 619 with
1136         the message from the attribute.
1137
1138 2002-07-24  Martin Baulig  <martin@gnome.org>
1139
1140         * cs-tokenizer.cs: Eat up trailing whitespaces and one-line comments in
1141         preprocessor directives, ensure that the argument to #define/#undef is
1142         exactly one identifier and that it's actually an identifier.
1143
1144         Some weeks ago I did a `#define DEBUG 1' myself and wondered why this
1145         did not work ....
1146
1147 2002-07-24  Martin Baulig  <martin@gnome.org>
1148
1149         * statement.cs (Foreach.ForeachHelperMethods): Added `Type element_type',
1150         initialize it to TypeManager.object_type in the constructor.
1151         (Foreach.GetEnumeratorFilter): Set `hm.element_type' to the return type
1152         of the `hm.get_current' method if we're using the collection pattern.
1153         (Foreach.EmitCollectionForeach): Use `hm.element_type' as the source type
1154         for the explicit conversion to make it work when we're using the collection
1155         pattern and the `Current' property has a different return type than `object'.
1156         Fixes #27713.
1157
1158 2002-07-24  Martin Baulig  <martin@gnome.org>
1159
1160         * delegate.cs (Delegate.VerifyMethod): Simply return null if the method
1161         does not match, but don't report any errors.  This method is called in
1162         order for all methods in a MethodGroupExpr until a matching method is
1163         found, so we don't want to bail out if the first method doesn't match.
1164         (NewDelegate.DoResolve): If none of the methods in the MethodGroupExpr
1165         matches, report the 123.  Fixes #28070.
1166
1167 2002-07-24  Martin Baulig  <martin@gnome.org>
1168
1169         * expression.cs (ArrayAccess.EmitStoreOpcode): Moved the
1170         TypeManager.TypeToCoreType() to the top of the method so the
1171         following equality checks will work.  Fixes #28107.
1172
1173 2002-07-24  Martin Baulig  <martin@gnome.org>
1174
1175         * cfold.cs (ConstantFold.DoConstantNumericPromotions): "If either
1176         operand is of type uint, and the other operand is of type sbyte,
1177         short or int, the operands are converted to type long." -
1178         Actually do what this comment already told us.  Fixes bug #28106,
1179         added test-150.cs.
1180
1181 2002-07-24  Martin Baulig  <martin@gnome.org>
1182
1183         * class.cs (MethodBase): New abstract class.  This is now a base
1184         class for Property, Indexer and Event to avoid some code duplication
1185         in their Define() and DefineMethods() methods.
1186         (MethodBase.DoDefine, MethodBase.DefineAccessor): Provide virtual
1187         generic methods for Define() and DefineMethods().
1188         (FieldBase): Derive from MemberBase, not MemberCore.
1189         (Property): Derive from MemberBase, not MemberCore.
1190         (Property.DefineMethod): Moved all the code from this method to the
1191         new MethodBase.DefineAccessor(), just call it with appropriate
1192         argumetnts.
1193         (Property.Define): Call the new Property.DoDefine(), this does some
1194         sanity checks and we don't need to duplicate the code everywhere.
1195         (Event): Derive from MemberBase, not MemberCore.
1196         (Event.Define): Use the new MethodBase.DefineAccessor() to define the
1197         accessors, this will also make them work with interface events.
1198         (Indexer): Derive from MemberBase, not MemberCore.
1199         (Indexer.DefineMethod): Removed, call MethodBase.DefineAccessor() insstead.
1200         (Indexer.Define): Use the new MethodBase functions.
1201
1202         * interface.cs (InterfaceEvent.InterfaceEvent): Added `Location loc'
1203         argument to the constructor.
1204         (Interface.FindMembers): Added support for interface events.
1205         (Interface.PopluateEvent): Implemented.
1206
1207         Added test-149.cs for this.  This also fixes bugs #26067 and #24256.
1208
1209 2002-07-22  Miguel de Icaza  <miguel@ximian.com>
1210
1211         * class.cs (TypeContainer.AddMethod): Adding methods do not use IsValid,
1212         but this is required to check for a method name being the same as
1213         the containing class.
1214
1215         Handle this now.
1216
1217 2002-07-22  Gonzalo Paniagua Javier <gonzalo@ximian.com>
1218
1219         * interface.cs: initialize variable.
1220
1221 2002-07-23  Martin Baulig  <martin@gnome.org>
1222
1223         Implemented the IndexerName attribute in interfaces.
1224
1225         * class.cs (TypeContainer.DefineIndexers): Don't set the indexer
1226         name if this is an explicit interface implementation.
1227         (Indexer.InterfaceIndexerName): New public variable.  If we're
1228         implementing an interface indexer, this is the IndexerName in that
1229         interface.  Otherwise, it's the IndexerName.
1230         (Indexer.DefineMethod): If we're implementing interface indexer,
1231         set InterfaceIndexerName.  Use the new Pending.IsInterfaceIndexer
1232         and Pending.ImplementIndexer methods.
1233         (Indexer.Define): Also define the PropertyBuilder if we're
1234         implementing an interface indexer and this is neither an explicit
1235         interface implementation nor do the IndexerName match the one in
1236         the interface.
1237
1238         * pending.cs (TypeAndMethods): Added `MethodInfo [] need_proxy'.
1239         If a method is defined here, then we always need to create a proxy
1240         for it.  This is used when implementing interface indexers.
1241         (Pending.IsInterfaceIndexer): New public method.
1242         (Pending.ImplementIndexer): New public method.
1243         (Pending.InterfaceMethod): Added `MethodInfo need_proxy' argument.
1244         This is used when implementing interface indexers to define a proxy
1245         if necessary.
1246         (Pending.VerifyPendingMethods): Look in the `need_proxy' array and
1247         define a proxy if necessary.
1248
1249         * interface.cs (Interface.IndexerName): New public variable.
1250         (Interface.PopulateIndexer): Set the IndexerName.
1251         (Interface.DefineIndexers): New private method.  Populate all the
1252         indexers and make sure their IndexerNames match.
1253
1254         * typemanager.cs (IndexerPropertyName): Added support for interface
1255         indexers.
1256
1257 2002-07-22  Martin Baulig  <martin@gnome.org>
1258
1259         * codegen.cs (EmitContext.HasReturnLabel): New public variable.
1260         (EmitContext.EmitTopBlock): Always mark the ReturnLabel and emit a
1261         ret if HasReturnLabel.
1262         (EmitContext.TryCatchLevel, LoopBeginTryCatchLevel): New public
1263         variables.
1264
1265         * statement.cs (Do.Emit, While.Emit, For.Emit, Foreach.Emit): Save
1266         and set the ec.LoopBeginTryCatchLevel.
1267         (Try.Emit): Increment the ec.TryCatchLevel while emitting the block.
1268         (Continue.Emit): If the ec.LoopBeginTryCatchLevel is smaller than
1269         the current ec.TryCatchLevel, the branch goes out of an exception
1270         block.  In this case, we need to use Leave and not Br.
1271
1272 2002-07-22  Martin Baulig  <martin@gnome.org>
1273
1274         * statement.cs (Try.Emit): Emit an explicit ret after the end of the
1275         block unless the block does not always return or it is contained in
1276         another try { ... } catch { ... } block.  Fixes bug #26506.
1277         Added verify-1.cs to the test suite.
1278
1279 2002-07-22  Martin Baulig  <martin@gnome.org>
1280
1281         * statement.cs (Switch.TableSwitchEmit): If we don't have a default,
1282         then we do not always return.  Fixes bug #24985.
1283
1284 2002-07-22  Martin Baulig  <martin@gnome.org>
1285
1286         * expression.cs (Invocation.OverloadedResolve): Do the BetterFunction()
1287         lookup on a per-class level; ie. walk up the class hierarchy until we
1288         found at least one applicable method, then choose the best among them.
1289         Fixes bug #24463 and test-29.cs.
1290
1291 2002-07-22  Martin Baulig  <martin@gnome.org>
1292
1293         * typemanager.cs (TypeManager.ArrayContainsMethod): Don't check the
1294         return types of the methods.  The return type is not part of the
1295         signature and we must not check it to make the `new' modifier work.
1296         Fixes bug #27999, also added test-147.cs.
1297         (TypeManager.TypeToCoreType): Added TypeManager.type_type.
1298
1299         * expression.cs (Invocation.DoResolve): Call TypeManager.TypeToCoreType()
1300         on the method's return type.
1301
1302 2002-07-21  Martin Baulig  <martin@gnome.org>
1303
1304         * assign.cs: Make this work if the rightmost source is a constant and
1305         we need to do an implicit type conversion.  Also adding a few more tests
1306         to test-38.cs which should have caught this.
1307
1308         * makefile.gnu: Disable debugging, there's already the mcs-mono2.exe
1309         target in the makefile for this.  The makefile.gnu is primarily intended
1310         for end-users who don't want to debug the compiler.
1311
1312 2002-07-21  Martin Baulig  <martin@gnome.org>
1313
1314         * assign.cs: Improved the Assign class so it can now handle embedded
1315         assignments (X = Y = Z = something).  As a side-effect this'll now also
1316         consume less local variables.  test-38.cs now passes with MCS, added
1317         a few new test cases to that test.
1318
1319 2002-07-20  Martin Baulig  <martin@gnome.org>
1320
1321         * expression.cs (Binary.EmitBranchable): Emit correct unsigned branch
1322         instructions.  Fixes bug #27977, also added test-146.cs.
1323
1324 2002-07-19  Gonzalo Paniagua Javier <gonzalo@ximian.com>
1325
1326         * cs-tokenizer.cs: fixed getHex ().
1327
1328 2002-07-19  Martin Baulig  <martin@gnome.org>
1329
1330         * expression.cs (Invocation.EmitParams): Use TypeManager.LookupType(),
1331         not Type.GetType() to lookup the array type.  This is needed when
1332         we're constructing an array of a user-defined type.
1333         (ArrayAccess.EmitDynamicInitializers): Only emit the Ldelema for
1334         single-dimensional arrays, but also for single-dimensial arrays of
1335         type decimal.
1336
1337 2002-07-19  Martin Baulig  <martin@gnome.org>
1338
1339         * expression.cs (New.DoEmit): Create a new LocalTemporary each time
1340         this function is called, it's not allowed to share LocalBuilders
1341         among ILGenerators.
1342
1343 2002-07-19  Martin Baulig  <martin@gnome.org>
1344
1345         * expression.cs (Argument.Resolve): Report an error 118 when trying
1346         to pass a type as argument.
1347
1348 2002-07-18  Martin Baulig  <martin@gnome.org>
1349
1350         * ecore.cs (Expression.ImplicitNumericConversion): Don't emit a
1351         Conv_R_Un for the signed `long' type.
1352
1353 2002-07-15  Miguel de Icaza  <miguel@ximian.com>
1354
1355         * expression.cs (MemberAccess.DoResolve): Do not reuse the field
1356         `expr' for the temporary result, as that will fail if we do
1357         multiple resolves on the same expression.
1358
1359 2002-07-05  Miguel de Icaza  <miguel@ximian.com>
1360
1361         * ecore.cs (SimpleNameResolve): Use ec.DeclSpace instead of
1362         ec.TypeContainer for looking up aliases.
1363
1364         * class.cs (TypeContainer): Remove LookupAlias from here.
1365
1366         * decl.cs (DeclSpace); Move here.
1367
1368 2002-07-01  Miguel de Icaza  <miguel@ximian.com>
1369
1370         * class.cs (FindMembers): Only call filter if the constructor
1371         bulider is not null.
1372
1373         Also handle delegates in `NestedTypes' now.  Now we will perform
1374         type lookups using the standard resolution process.  This also
1375         fixes a bug.
1376
1377         * decl.cs (DeclSpace.ResolveType): New type resolution routine.
1378         This uses Expressions (the limited kind that can be parsed by the
1379         tree) instead of strings.
1380
1381         * expression.cs (ComposedCast.ToString): Implement, used to flag
1382         errors since now we have to render expressions.
1383
1384         (ArrayCreation): Kill FormElementType.  Use ComposedCasts in
1385         FormArrayType.
1386
1387         * ecore.cs (SimpleName.ToString): ditto.
1388
1389         * cs-parser.jay: Instead of using strings to assemble types, use
1390         Expressions to assemble the type (using SimpleName, ComposedCast,
1391         MemberAccess).  This should fix the type lookups in declarations,
1392         because we were using a different code path for this.
1393
1394         * statement.cs (Block.Resolve): Continue processing statements
1395         even when there is an error.
1396
1397 2002-07-17  Miguel de Icaza  <miguel@ximian.com>
1398
1399         * class.cs (Event.Define): Also remove the `remove' method from
1400         the list of pending items.
1401
1402         * expression.cs (ParameterReference): Use ldarg.N (0..3) to
1403         generate more compact code.
1404
1405 2002-07-17  Martin Baulig  <martin@gnome.org>
1406
1407         * const.cs (Const.LookupConstantValue): Add support for constant
1408         `unchecked' and `checked' expressions.
1409         Also adding test case test-140.cs for this.
1410
1411 2002-07-17  Martin Baulig  <martin@gnome.org>
1412
1413         * statement.cs (Foreach.GetEnumeratorFilter): When compiling corlib,
1414         check whether mi.ReturnType implements the IEnumerator interface; the
1415         `==' and the IsAssignableFrom() will fail in this situation.
1416
1417 2002-07-16  Ravi Pratap  <ravi@ximian.com>
1418
1419         * ecore.cs (SimpleName.SimpleNameResolve) : Apply Gonzalo's fix
1420         here too.
1421
1422 2002-07-16  Gonzalo Paniagua Javier <gonzalo@ximian.com>
1423
1424         * expression.cs: fixed bug #27811.
1425
1426 2002-07-14  Miguel de Icaza  <miguel@ximian.com>
1427
1428         * expression.cs (ParameterReference.AddressOf): Patch from Paolo
1429         Molaro: when we are a ref, the value already contains a pointer
1430         value, do not take the address of it.
1431
1432 2002-07-14 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
1433         * removed mb-parser.jay and mb-tokenizer.cs
1434
1435 Sat Jul 13 19:38:03 CEST 2002 Paolo Molaro <lupus@ximian.com>
1436
1437         * expression.cs: check against the building corlib void type.
1438
1439 Sat Jul 13 19:35:58 CEST 2002 Paolo Molaro <lupus@ximian.com>
1440
1441         * ecore.cs: fix for valuetype static readonly fields: when
1442         initializing them, we need their address, not the address of a copy.
1443
1444 Sat Jul 13 17:32:53 CEST 2002 Paolo Molaro <lupus@ximian.com>
1445
1446         * typemanager.cs: register also enum_type in corlib.
1447
1448 Sat Jul 13 15:59:47 CEST 2002 Paolo Molaro <lupus@ximian.com>
1449
1450         * class.cs: allow calling this (but not base) initializers in structs.
1451
1452 Sat Jul 13 15:12:06 CEST 2002 Paolo Molaro <lupus@ximian.com>
1453
1454         * ecore.cs: make sure we compare against the building base types
1455         in GetTypeSize ().
1456
1457 Sat Jul 13 15:10:32 CEST 2002 Paolo Molaro <lupus@ximian.com>
1458
1459         * typemanager.cs: fix TypeToCoreType() to handle void and object
1460         (corlib gets no more typerefs after this change).
1461
1462 2002-07-12  Miguel de Icaza  <miguel@ximian.com>
1463
1464         * expression.cs (ArrayCreation.EmitArrayArguments): use
1465         Conv.Ovf.U4 for unsigned and Conv.Ovf.I4 for signed.
1466
1467         (ArrayAccess.LoadArrayAndArguments): Use Conv_Ovf_I and
1468         Conv_Ovf_I_Un for the array arguments.  Even if C# allows longs as
1469         array indexes, the runtime actually forbids them.
1470
1471         * ecore.cs (ExpressionToArrayArgument): Move the conversion code
1472         for array arguments here.
1473
1474         * expression.cs (EmitLoadOpcode): System.Char is a U2, use that
1475         instead of the default for ValueTypes.
1476
1477         (New.DoEmit): Use IsValueType instead of
1478         IsSubclassOf (value_type)
1479         (New.DoResolve): ditto.
1480         (Invocation.EmitCall): ditto.
1481
1482         * assign.cs (Assign): ditto.
1483
1484         * statement.cs (Unsafe): Ok, so I got the semantics wrong.
1485         Statements *are* currently doing part of their resolution during
1486         Emit.
1487
1488         Expressions do always resolve during resolve, but statements are
1489         only required to propagate resolution to their children.
1490
1491 2002-07-11  Miguel de Icaza  <miguel@ximian.com>
1492
1493         * driver.cs (CSCParseOption): Finish the /r: and /lib: support.
1494
1495         (LoadAssembly): Do not add the dll if it is already specified
1496
1497         (MainDriver): Add the System directory to the link path at the end,
1498         after all the other -L arguments.
1499
1500         * expression.cs (ArrayAccess.EmitLoadOpcode): I was using the
1501         wrong opcode for loading bytes and bools (ldelem.i1 instead of
1502         ldelem.u1) and using the opposite for sbytes.
1503
1504         This fixes Digger, and we can finally run it.
1505
1506         * driver.cs (UnixParseOption): Move the option parsing here.
1507         (CSCParseOption): Implement CSC-like parsing of options.
1508
1509         We now support both modes of operation, the old Unix way, and the
1510         new CSC-like way.  This should help those who wanted to make cross
1511         platform makefiles.
1512
1513         The only thing broken is that /r:, /reference: and /lib: are not
1514         implemented, because I want to make those have the same semantics
1515         as the CSC compiler has, and kill once and for all the confussion
1516         around this.   Will be doing this tomorrow.
1517
1518         * statement.cs (Unsafe.Resolve): The state is checked during
1519         resolve, not emit, so we have to set the flags for IsUnsfe here.
1520
1521 2002-07-10  Miguel de Icaza  <miguel@ximian.com>
1522
1523         * expression.cs (MemberAccess.ResolveMemberAccess): Since we can
1524         not catch the Error_ObjectRefRequired in SimpleName (as it is
1525         possible to have a class/instance variable name that later gets
1526         deambiguated), we have to check this here.
1527
1528 2002-07-10  Ravi Pratap  <ravi@ximian.com>
1529
1530         * class.cs (TypeContainer.GetFieldFromEvent): Move away from here,
1531         make static and put into Expression.
1532
1533         (Event.Define): Register the private field of the event with the
1534         TypeManager so that GetFieldFromEvent can get at it.
1535
1536         (TypeManager.RegisterPrivateFieldOfEvent): Implement to
1537         keep track of the private field associated with an event which
1538         has no accessors.
1539
1540         (TypeManager.GetPrivateFieldOfEvent): Implement to get at the
1541         private field.
1542
1543         * ecore.cs (GetFieldFromEvent): RE-write to use the above methods.
1544
1545 2002-07-10  Miguel de Icaza  <miguel@ximian.com>
1546
1547         * expression.cs (Binary.EmitBranchable): this routine emits the
1548         Binary expression in a branchable context.  This basically means:
1549         we need to branch somewhere, not just get the value on the stack.
1550
1551         This works together with Statement.EmitBoolExpression.
1552
1553         * statement.cs (Statement.EmitBoolExpression): Use
1554         EmitBranchable.
1555
1556 2002-07-09  Miguel de Icaza  <miguel@ximian.com>
1557
1558         * statement.cs (For): Reduce the number of jumps in loops.
1559
1560         (For): Implement loop inversion for the For statement.
1561
1562         (Break): We can be breaking out of a Try/Catch controlled section
1563         (foreach might have an implicit try/catch clause), so we need to
1564         use Leave instead of Br.
1565
1566         * ecore.cs (FieldExpr.AddressOf): Fix for test-139 (augmented
1567         now).  If the instace expression supports IMemoryLocation, we use
1568         the AddressOf method from the IMemoryLocation to extract the
1569         address instead of emitting the instance.
1570
1571         This showed up with `This', as we were emitting the instance
1572         always (Emit) instead of the Address of This.  Particularly
1573         interesting when This is a value type, as we dont want the Emit
1574         effect (which was to load the object).
1575
1576 2002-07-08  Miguel de Icaza  <miguel@ximian.com>
1577
1578         * attribute.cs: Pass the entry point to the DefinePInvokeMethod
1579
1580         * statement.cs (Checked): Set the CheckedState during the resolve
1581         process too, as the ConvCast operations track the checked state on
1582         the resolve process, and not emit.
1583
1584         * cs-parser.jay (namespace_member_declaration): Flag that we have
1585         found a declaration when we do.  This is used to flag error 1529
1586
1587         * driver.cs: Report ok when we display the help only.
1588
1589 2002-07-06  Andrew Birkett  <adb@tardis.ed.ac.uk>
1590
1591         * cs-tokenizer.cs (xtoken): Improve handling of string literals.
1592
1593 2002-07-04  Miguel de Icaza  <miguel@ximian.com>
1594
1595         * cs-tokenizer.cs (define): We also have to track locally the
1596         defines.  AllDefines is just used for the Conditional Attribute,
1597         but we also need the local defines for the current source code.
1598
1599 2002-07-03  Miguel de Icaza  <miguel@ximian.com>
1600
1601         * statement.cs (While, For, Do): These loops can exit through a
1602         Break statement, use this information to tell whether the
1603         statement is the last piece of code.
1604
1605         (Break): Flag that we break.
1606
1607         * codegen.cs (EmitContexts): New `Breaks' state variable.
1608
1609 2002-07-03  Martin Baulig  <martin@gnome.org>
1610
1611         * class.cs (TypeContainer.MethodModifiersValid): Allow override
1612         modifiers in method declarations in structs.  Otherwise, you won't
1613         be able to override things like Object.Equals().
1614
1615 2002-07-02  Miguel de Icaza  <miguel@ximian.com>
1616
1617         * class.cs (Method, Property, Indexer): Do not allow the public
1618         modifier to be used in explicit interface implementations.
1619
1620         (TypeContainer.MethodModifiersValid): Catch virtual, abstract and
1621         override modifiers in method declarations in structs
1622
1623 2002-07-02   Andrew Birkett <adb@tardis.ed.ac.uk>
1624
1625         * cs-tokenizer.cs (adjust_int, adjust_real): Do not abort on
1626         integer or real overflow, report an error
1627
1628 2002-07-02  Martin Baulig  <martin@gnome.org>
1629
1630         * typemanager.cs (TypeManager.InitCoreTypes): When compiling
1631         corlib, dynamically call AssemblyBuilder.SetCorlibTypeBuilders()
1632         to tell the runtime about our newly created System.Object and
1633         System.ValueType types.
1634
1635 2002-07-02  Miguel de Icaza  <miguel@ximian.com>
1636
1637         * expression.cs (This): Use Stobj/Ldobj when we are a member of a
1638         struct instead of Ldarg/Starg.
1639
1640 2002-07-02  Martin Baulig  <martin@gnome.org>
1641
1642         * expression.cs (Indirection.Indirection): Call
1643         TypeManager.TypeToCoreType() on `expr.Type.GetElementType ()'.
1644
1645 2002-07-02  Martin Baulig  <martin@gnome.org>
1646
1647         * expression.cs (ArrayAccess.EmitStoreOpcode): If the type is a
1648         ValueType, call TypeManager.TypeToCoreType() on it.
1649         (Invocations.EmitParams): Call TypeManager.TypeToCoreType() on
1650         the OpCodes.Newarr argument.
1651
1652 2002-07-02  Martin Baulig  <martin@gnome.org>
1653
1654         * expression.cs (Invocation.EmitCall): When compiling corlib,
1655         replace all calls to the system's System.Array type to calls to
1656         the newly created one.
1657
1658         * typemanager.cs (TypeManager.InitCodeHelpers): Added a few more
1659         System.Array methods.
1660         (TypeManager.InitCoreTypes): When compiling corlib, get the methods
1661         from the system's System.Array type which must be replaced.
1662
1663 Tue Jul 2 19:05:05 CEST 2002 Paolo Molaro <lupus@ximian.com>
1664
1665         * typemanager.cs: load unverifiable_code_ctor so we can build
1666         corlib using the correct type. Avoid using GetTypeCode() with
1667         TypeBuilders.
1668         * rootcontext.cs: uses TypeManager.unverifiable_code_ctor and
1669         TypeManager.object_type to allow building corlib.
1670
1671 Tue Jul 2 19:03:19 CEST 2002 Paolo Molaro <lupus@ximian.com>
1672
1673         * ecore.cs: handle System.Enum separately in LoadFromPtr().
1674
1675 2002-07-01  Martin Baulig  <martin@gnome.org>
1676
1677         * class.cs: Make the last change actually work, we need to check
1678         whether `ifaces != null' to avoid a crash.
1679
1680 Mon Jul 1 16:15:03 CEST 2002 Paolo Molaro <lupus@ximian.com>
1681
1682         * class.cs: when we build structs without fields that implement
1683         interfaces, we need to add the interfaces separately, since there is
1684         no API to both set the size and add the interfaces at type creation
1685         time.
1686
1687 Mon Jul 1 14:50:47 CEST 2002 Paolo Molaro <lupus@ximian.com>
1688
1689         * expression.cs: the dimension arguments to the array constructors
1690         need to be converted if they are a long.
1691
1692 Mon Jul 1 12:26:12 CEST 2002 Paolo Molaro <lupus@ximian.com>
1693
1694         * class.cs: don't emit ldarg.0 if there is no parent constructor
1695         (fixes showstopper for corlib).
1696
1697 2002-06-29  Martin Baulig  <martin@gnome.org>
1698
1699         MCS now compiles corlib on GNU/Linux :-)
1700
1701         * attribute.cs (Attribute.ApplyAttributes): Treat Accessors like Method,
1702         ie. check for MethodImplOptions.InternalCall.
1703
1704         * class.cs (TypeContainer.DefineType): When compiling corlib, both parent
1705         and TypeManager.attribute_type are null, so we must explicitly check
1706         whether parent is not null to find out whether it's an attribute type.
1707         (Property.Emit): Always call Attribute.ApplyAttributes() on the GetBuilder
1708         and SetBuilder, not only if the property is neither abstract nor external.
1709         This is necessary to set the MethodImplOptions on the accessor methods.
1710         (Indexer.Emit): Call Attribute.ApplyAttributes() on the GetBuilder and
1711         SetBuilder, see Property.Emit().
1712
1713         * rootcontext.cs (RootContext.PopulateTypes): When compiling corlib, don't
1714         populate "System.Object", "System.ValueType" and "System.Attribute" since
1715         they've already been populated from BootCorlib_PopulateCoreTypes().
1716
1717 2002-06-29  Martin Baulig  <martin@gnome.org>
1718
1719         * ecore.cs (Expression.ImplicitReferenceConversionExists): If expr
1720         is the NullLiteral, we also need to make sure that target_type is not
1721         an enum type.
1722
1723 2002-06-29  Martin Baulig  <martin@gnome.org>
1724
1725         * rootcontext.cs (RootContext.ResolveCore): We must initialize
1726         `TypeManager.multicast_delegate_type' and `TypeManager.delegate_type'
1727         before calling BootstrapCorlib_ResolveDelegate ().
1728
1729 2002-06-27  Gonzalo Paniagua Javier <gonzalo@ximian.com>
1730
1731         * statement.cs: fixed build-breaker. All tests passed ok.
1732
1733 2002-06-27  Martin Baulig  <martin@gnome.org>
1734
1735         * typemanager.cs (TypeManager.VerifyUnManaged): Added explicit check
1736         for System.Decimal when compiling corlib.
1737
1738 2002-06-27  Martin Baulig  <martin@gnome.org>
1739
1740         * statement.cs (Switch.TableSwitchEmit): Make this work with empty
1741         switch blocks which contain nothing but a default clause.
1742
1743 2002-06-26  Andrew  <adb@tardis.ed.ac.uk>
1744
1745        * ../errors/cs1501-3.cs: Added new test for struct ctr typechecks.
1746
1747 2002-06-27  Martin Baulig  <martin@gnome.org>
1748
1749         * ecore.cs (PropertyExpr.PropertyExpr): Call
1750         TypeManager.TypeToCoreType() on the `pi.PropertyType'.
1751
1752         * typemanager.cs (TypeManager.TypeToCoreType): Return if the type
1753         is already a TypeBuilder.
1754
1755 2002-06-27  Martin Baulig  <martin@gnome.org>
1756
1757         * ecore.cs (Expression.ImplicitReferenceConversionExists): Use
1758         `target_type == TypeManager.array_type', not IsAssignableFrom() in
1759         the "from an array-type to System.Array" case.  This makes it work
1760         when compiling corlib.
1761
1762 2002-06-27  Martin Baulig  <martin@gnome.org>
1763
1764         * ecore.cs (Expression.SimpleNameResolve): If the expression is a
1765         non-static PropertyExpr, set its InstanceExpression.  This makes
1766         the `ICollection.Count' property work in System/Array.cs.
1767
1768 2002-06-25  Andrew Birkett  <adb@tardis.ed.ac.uk>
1769
1770         * driver.cs: Made error handling more consistent.  Errors now
1771         tracked by Report class, so many methods which used to return int
1772         now return void.  Main() now prints success/failure and
1773         errors/warnings message.
1774
1775         Renamed '--probe' compiler argument to '--expect-error'.  Removed
1776         the magic number return values (123 and 124).  Now, if the
1777         expected error occurs, the compiler exits with success (exit value
1778         0).  If the compilation completes without seeing that particular
1779         error, the compiler exits with failure (exit value 1).  The
1780         makefile in mcs/errors has been changed to handle the new behaviour.
1781
1782         * report.cs: Made 'expected error' number a property and renamed
1783         it from 'Probe' to 'ExpectedError'.
1784
1785         * genericparser.cs: Removed error handling support, since it is
1786         now all done by Report class.
1787
1788         * cs-parser.jay, mb-parser.jay: Errors are tracked by Report
1789         class, so parse() no longer returns an int.
1790
1791         * namespace.cs: Use Report.Error instead of GenericParser.error
1792
1793 2002-06-22  Miguel de Icaza  <miguel@ximian.com>
1794
1795         * class.cs (TypeContainer.AddMethod, TypeContainer.AddIndexer,
1796         TypeContainer.AddOperator): At the front of the list put the
1797         explicit implementations, so they get resolved/defined first.
1798
1799 2002-06-21  Miguel de Icaza  <miguel@ximian.com>
1800
1801         * class.cs (TypeContainer.VerifyImplements): Verifies that a given
1802         interface type is implemented by this TypeContainer.  Used during
1803         explicit interface implementation.
1804
1805         (Property.Define, Indexer.Define, Method.Define): Validate that
1806         the given interface in the explicit implementation is one of the
1807         base classes for the containing type.
1808
1809         Also if we are explicitly implementing an interface, but there is
1810         no match in the pending implementation table, report an error.
1811
1812         (Property.Define): Only define the property if we are
1813         not explicitly implementing a property from an interface.  Use the
1814         correct name also for those properties (the same CSC uses,
1815         although that is really not needed).
1816
1817         (Property.Emit): Do not emit attributes for explicitly implemented
1818         properties, as there is no TypeBuilder.
1819
1820         (Indexer.Emit): ditto.
1821
1822         Hiding then means that we do not really *implement* a pending
1823         implementation, which makes code fail.
1824
1825 2002-06-22  Martin Baulig  <martin@gnome.org>
1826
1827         * ecore.cs (Expression.Constantify): Call TypeManager.TypeToCoreType() on
1828         the return value of Object.GetType().  [FIXME: we need to do this whenever
1829         we get a type back from the reflection library].
1830
1831 Fri Jun 21 13:37:57 CEST 2002 Paolo Molaro <lupus@ximian.com>
1832
1833         * typemanager.cs: make ExpandInterfaces() slip duplicated interfaces.
1834
1835 2002-06-20  Miguel de Icaza  <miguel@ximian.com>
1836
1837         * attribute.cs: Return null if we can not look up the type.
1838
1839         * class.cs (TypeContainer.GetClassBases): Use ExpandInterfaces on
1840         the interface types found.
1841
1842         * interface.cs (Interface.GetInterfaceBases): Use ExpandInterfaces on the
1843         interface types found.
1844
1845         * typemanager.cs (GetInterfaces): Make this routine returns alll
1846         the interfaces and work around the lame differences between
1847         System.Type and System.Reflection.Emit.TypeBuilder in the results
1848         result for GetInterfaces.
1849
1850         (ExpandInterfaces): Given an array of interface types, expand and
1851         eliminate repeated ocurrences of an interface.  This expands in
1852         context like: IA; IB : IA; IC : IA, IB; the interface "IC" to
1853         be IA, IB, IC.
1854
1855 2002-06-21  Martin Baulig  <martin@gnome.org>
1856
1857         * typemanager.cs (TypeManager.EnumToUnderlying): It's now safe to call this function
1858         on System.Enum.
1859
1860 2002-06-21  Martin Baulig  <martin@gnome.org>
1861
1862         * typemanager.cs (TypeManager.TypeToCoreType): New function.  When compiling corlib
1863         and called with one of the core types, return the corresponding typebuilder for
1864         that type.
1865
1866         * expression.cs (ArrayAccess.DoResolve): Call TypeManager.TypeToCoreType() on the
1867         element type.
1868
1869 2002-06-21  Martin Baulig  <martin@gnome.org>
1870
1871         * ecore.cs (Expression.ExplicitReferenceConversionExists): Use
1872         `target_type.IsArray' instead of `target_type.IsSubclassOf (TypeManager.array_type)'.
1873         (Expression.ConvertReferenceExplicit): Likewise.
1874
1875         * expression.cs (ElementAccess.DoResolve): Likewise.
1876         (ElementAccess.DoResolveLValue): Likewise.
1877
1878 2002-06-10  Martin Baulig  <martin@gnome.org>
1879
1880         * interface.cs (Interface.PopulateIndexer): When creating the setter, we need to
1881         add the "value" parameter to the parameter list.
1882
1883         * statement.cs (Fixed.Emit): Pass the return value of the child block's Emit()
1884         to our caller.
1885
1886 2002-06-19  Miguel de Icaza  <miguel@ximian.com>
1887
1888         * expression.cs (ArrayCreation.ExpressionToArrayArgument): Convert
1889         the argument to an int, uint, long or ulong, per the spec.  Also
1890         catch negative constants in array creation.
1891
1892 Thu Jun 20 17:56:48 CEST 2002 Paolo Molaro <lupus@ximian.com>
1893
1894         * class.cs: do not allow the same interface to appear twice in
1895         the definition list.
1896
1897 Wed Jun 19 22:33:37 CEST 2002 Paolo Molaro <lupus@ximian.com>
1898
1899         * ecore.cs: don't use ldlen with System.Array.
1900
1901 Wed Jun 19 20:57:40 CEST 2002 Paolo Molaro <lupus@ximian.com>
1902
1903         * ecore.cs: stobj requires a type argument. Handle indirect stores on enums.
1904
1905 Wed Jun 19 20:17:59 CEST 2002 Paolo Molaro <lupus@ximian.com>
1906
1907         * modifiers.cs: produce correct field attributes for protected
1908         internal. Easy fix so miguel can work on ther harder stuff:-)
1909
1910 2002-06-18  Miguel de Icaza  <miguel@ximian.com>
1911
1912         * pending.cs: New file.  Move the code from class.cs here.
1913         Support clearning the pending flag for all methods (when not doing
1914         explicit interface implementation).
1915
1916 Tue Jun 18 10:36:22 CEST 2002 Paolo Molaro <lupus@ximian.com>
1917
1918         * rootcontext.cs: added a couple more types needed to bootstrap.
1919
1920 2002-06-17  Miguel de Icaza  <miguel@ximian.com>
1921
1922         * typemanager.cs (GetConstructor): Use DeclaredOnly to look the
1923         constructor in the type, instead of any constructor in the type
1924         hierarchy.  Thanks to Paolo for finding this bug (it showed up as
1925         a bug in the Mono runtime when applying the params attribute).
1926
1927 2002-06-16  Rafael Teixeira  <rafaelteixeirabr@hotmail.com>
1928         * changed namespace.cs to use "GenericParser.error(...)" instead of "CSharpParser.error(...)"
1929
1930 2002-06-14  Rachel Hestilow  <hestilow@ximian.com>
1931
1932         * expression.cs (Unary.ResolveOperator): Use TypeManager
1933         to resolve the type.
1934
1935 2002-06-13  Ravi Pratap  <ravi@ximian.com>
1936
1937         * cs-parser.jay (enum_member_declaration): Pass in the attributes
1938         attached.
1939
1940         * enum.cs (AddEnumMember): Add support to store the attributes associated
1941         with each member too.
1942
1943         * attribute.cs (CheckAttribute, ApplyAttributes): Update to handle
1944         field builders too - this takes care of the enum member case.
1945
1946 2002-06-10  Rachel Hestilow  <hestilow@ximian.com>
1947
1948         * typemanager.cs (TypeManager.VerifyUnManaged): Allow
1949         address-of operator on both value types and pointers.
1950
1951 2002-06-10  Martin Baulig  <martin@gnome.org>
1952
1953         * interface.cs (Interface.PopulateIndexer): Add the indexer's
1954         PropertyBuilder to the `property_builders' list.
1955
1956         * expression.cs (Indexers.GetIndexersForTypeOrInterface): New private method.
1957         (Indexers.GetIndexersForType): Call GetIndexersForTypeOrInterface() on the
1958         `lookup_type' and all its interfaces.  Unfortunately, Type.FindMembers() won't
1959         find any indexers which are inherited from an interface.
1960
1961 2002-06-09  Martin Baulig  <martin@gnome.org>
1962
1963         * const.cs (Const.LookupConstantValue): Convert `Expr' to a literal of
1964         the same type as the constant if necessary.  There's also a test-130.cs
1965         for this.
1966
1967         * enum.cs (Enum.ChangeEnumType): Moved to typemanager.cs and made public.
1968
1969         * typemanager.cs (TypeManager.ChangeType): Previously known as
1970         Enum.ChangeEnumType().
1971
1972 2002-06-09  Martin Baulig  <martin@gnome.org>
1973
1974         * expression.cs (Cast.TryReduce): Added support for consts.
1975
1976 2002-06-08  Ravi Pratap  <ravi@ximian.com>
1977
1978         * class.cs (Accessor): Hold attributes information so we can pass
1979         it along.
1980
1981         * cs-parser.jay (get_accessor_declaration, set_accessor_declaration):
1982         Modify to pass in attributes attached to the methods.
1983
1984         (add_accessor_declaration, remove_accessor_declaration): Ditto.
1985
1986         * attribute.cs (ApplyAttributes, CheckAttribute): Update accordingly
1987         to handle the Accessor kind :-)
1988
1989         * class.cs (Property.Emit, Event.Emit): Apply attributes to the accessors
1990
1991 2002-06-08  Martin Baulig  <martin@gnome.org>
1992
1993         * expression.cs (Unary.TryReduceNegative): Added support for
1994         ULongConstants.
1995
1996 2002-06-08  Martin Baulig  <martin@gnome.org>
1997
1998         * enum.cs (Enum.LookupEnumValue): Don't report an error if the
1999         name can't be found in the `defined_names' - the caller will do a
2000         MemberLookup in this case and thus find methods in System.Enum
2001         such as Enum.IsDefined().
2002
2003 2002-06-08  Martin Baulig  <martin@gnome.org>
2004
2005         * enum.cs (Enum.ChangeEnumType): This is a custom version of
2006         Convert.ChangeType() which works with TypeBuilder created types.
2007         (Enum.LookupEnumValue, Enum.Define): Use it here.
2008
2009         * class.cs (TypeContainer.RegisterRequiredImplementations): Added
2010         `TypeBuilder.BaseType != null' check.
2011         (TypeContainer.FindMembers): Only lookup parent members if we
2012         actually have a parent.
2013         (Method.EmitDestructor): Added `ec.ContainerType.BaseType != null' check.
2014         (ConstructorInitializer.Resolve): Likewise.
2015
2016         * interface.cs (Interface.FindMembers): Added
2017         `TypeBuilder.BaseType != null' check.
2018
2019         * rootcontext.cs (RootContext.ResolveCore): Added
2020         "System.Runtime.CompilerServices.IndexerNameAttribute" to
2021         classes_second_stage.
2022
2023         * typemanager.cs (TypeManager.InitCoreTypes): Don't initialize
2024         debug_type and trace_type when compiling with --nostdlib.
2025
2026 2002-06-07  Martin Baulig  <martin@gnome.org>
2027
2028         * class.cs (TypeContainer): Added `have_nonstatic_fields' field.
2029         (AddField): Set it to true when adding a non-static field.
2030         (DefineType): Use `have_nonstatic_fields' to find out whether we
2031         have non-static fields, not `Fields != null'.
2032
2033 2002-06-02  Miguel de Icaza  <miguel@ximian.com>
2034
2035         * ecore.cs (SimpleNameResolve): Removed simple bug (we were
2036         dereferencing a null on the static-field code path)
2037
2038 2002-05-30  Martin Baulig  <martin@gnome.org>
2039
2040         * codegen.cs (InitMonoSymbolWriter): Added `string[] args' argument
2041         to take command line arguments.  Use reflection to call the new
2042         custom `Initialize' function on the symbol writer and pass it the
2043         command line arguments.
2044
2045         * driver.cs (--debug-args): New command line argument to pass command
2046         line arguments to the symbol writer.
2047
2048 2002-05-28  Miguel de Icaza  <miguel@ximian.com>
2049
2050         * assign.cs (DoResolve): Forgot to do the implicit conversion to
2051         the target type for indexers and properties.  Thanks to Joe for
2052         catching this.
2053
2054 2002-05-27  Miguel de Icaza  <miguel@ximian.com>
2055
2056         * typemanager.cs (MethodFlags): returns the method flags
2057         (Obsolete/ShouldIgnore) that control warning emission and whether
2058         the invocation should be made, or ignored.
2059
2060         * expression.cs (Invocation.Emit): Remove previous hack, we should
2061         not do this on matching a base type, we should do this based on an attribute
2062
2063         Only emit calls to System.Diagnostics.Debug and
2064         System.Diagnostics.Trace if the TRACE and DEBUG defines are passed
2065         on the command line.
2066
2067         * rootcontext.cs: Global settings for tracing and debugging.
2068
2069         * cs-tokenizer.cs (define): New utility function to track
2070         defines.   Set the global settings for TRACE and DEBUG if found.
2071
2072 2002-05-25  Ravi Pratap  <ravi@ximian.com>
2073
2074         * interface.cs (Populate*): Pass in the TypeContainer as well as
2075         the DeclSpace as parameters so that we can create EmitContexts and
2076         then use that to apply attributes etc.
2077
2078         (PopulateMethod, PopulateEvent, PopulateProperty)
2079         (PopulateIndexer): Apply attributes everywhere.
2080
2081         * attribute.cs (CheckAttribute): Include InterfaceMethod, InterfaceEvent
2082         etc.
2083
2084         (ApplyAttributes): Update accordingly.
2085
2086         We now apply interface attributes for all members too.
2087
2088 2002-05-26  Miguel de Icaza  <miguel@ximian.com>
2089
2090         * class.cs (Indexer.Define); Correctly check if we are explicit
2091         implementation (instead of checking the Name for a ".", we
2092         directly look up if the InterfaceType was specified).
2093
2094         Delay the creation of the PropertyBuilder.
2095
2096         Only create the PropertyBuilder if we are not an explicit
2097         interface implementation.   This means that explicit interface
2098         implementation members do not participate in regular function
2099         lookups, and hence fixes another major ambiguity problem in
2100         overload resolution (that was the visible effect).
2101
2102         (DefineMethod): Return whether we are doing an interface
2103         implementation.
2104
2105         * typemanager.cs: Temporary hack until we get attributes in
2106         interfaces (Ravi is working on that) and we get IndexerName
2107         support in interfaces.
2108
2109         * interface.cs: Register the indexers as properties.
2110
2111         * attribute.cs (Attribute.Resolve): Catch the error, and emit a
2112         warning, I have verified that this is a bug in the .NET runtime
2113         (JavaScript suffers of the same problem).
2114
2115         * typemanager.cs (MemberLookup): When looking up members for
2116         interfaces, the parent of an interface is the implicit
2117         System.Object (so we succeed in searches of Object methods in an
2118         interface method invocation.  Example:  IEnumerable x;  x.ToString
2119         ())
2120
2121 2002-05-25  Miguel de Icaza  <miguel@ximian.com>
2122
2123         * class.cs (Event): Events should also register if they do
2124         implement the methods that an interface requires.
2125
2126         * typemanager.cs (MemberLookup); use the new GetInterfaces
2127         method.
2128
2129         (GetInterfaces): The code used to lookup interfaces for a type is
2130         used in more than one place, factor it here.
2131
2132         * driver.cs: Track the errors at the bottom of the file, we kept
2133         on going.
2134
2135         * delegate.cs (NewDelegate.Emit): We have to emit a null as the
2136         instance if the method we are calling is static!
2137
2138 2002-05-24  Miguel de Icaza  <miguel@ximian.com>
2139
2140         * attribute.cs (ApplyAttributes): Make this function filter out
2141         the IndexerName attribute (as that attribute in reality is never
2142         applied) and return the string constant for the IndexerName
2143         attribute.
2144
2145         * class.cs (TypeContainer.Emit): Validate that all the indexers
2146         have the same IndexerName attribute, and if so, set the
2147         DefaultName attribute on the class.
2148
2149         * typemanager.cs: The return value might contain other stuff (not
2150         only methods).  For instance, consider a method with an "Item"
2151         property and an Item method.
2152
2153         * class.cs: If there is a problem with the parameter types,
2154         return.
2155
2156 2002-05-24  Ravi Pratap  <ravi@ximian.com>
2157
2158         * ecore.cs (ImplicitConversionExists): Wrapper function which also
2159         looks at user defined conversion after making a call to
2160         StandardConversionExists - we need this for overload resolution.
2161
2162         * expression.cs : Update accordingly the various method calls.
2163
2164         This fixes 2 bugs filed against implicit user defined conversions
2165
2166 2002-05-22  Miguel de Icaza  <miguel@ximian.com>
2167
2168         * statement.cs: Track the result of the assignment.
2169
2170 2002-05-21  Miguel de Icaza  <miguel@ximian.com>
2171
2172         * expression.cs (MemberAccess): Improved error reporting for
2173         inaccessible members.
2174
2175 2002-05-22  Martin Baulig  <martin@gnome.org>
2176
2177         * makefile (mcs-mono2.exe): New target.  This is mcs compiled with
2178         itself with debugging support.
2179
2180 2002-05-22  Martin Baulig  <martin@gnome.org>
2181
2182         * typemanager.cs ("System.Runtime.InteropServices.StructLayoutAttribute"):
2183         Removed, this isn't needed anymore.
2184
2185 2002-05-20  Martin Baulig  <martin@gnome.org>
2186
2187         * typemanager.cs (InitEnumUnderlyingTypes): "System.Char" can't
2188         be underlying type for an enum.
2189
2190 2002-05-20  Miguel de Icaza  <miguel@ximian.com>
2191
2192         * typemanager.cs (InitEnumUnderlyingTypes): New helper function
2193         that splits out the loading of just the core types.
2194
2195         * rootcontext.cs (ResolveCore): Split the struct resolution in
2196         two, so we can load the enumeration underlying types before any
2197         enums are used.
2198
2199         * expression.cs (Is): Bandaid until we fix properly Switch (see
2200         bug #24985 for details).
2201
2202         * typemanager.cs (ImplementsInterface): The hashtable will contain
2203         a null if there are no interfaces implemented.
2204
2205 2002-05-18  Miguel de Icaza  <miguel@ximian.com>
2206
2207         * cs-parser.jay (indexer_declarator): It is fine to have array
2208         parameters
2209
2210 2002-05-17  Miguel de Icaza  <miguel@ximian.com>
2211
2212         * typemanager.cs: (RegisterBuilder): New function used to register
2213         TypeBuilders that implement interfaces.  Since
2214         TypeBuilder.GetInterfaces (as usual) does not work with lame
2215         Reflection.Emit.
2216         (AddUserType): register interfaces.
2217
2218         (ImplementsInterface): Use the builder_to_ifaces hash if we are
2219         dealing with TypeBuilder.  Also, arrays are showing up as
2220         SymbolTypes, which are not TypeBuilders, but whose GetInterfaces
2221         methods can not be invoked on them!
2222
2223         * ecore.cs (ExplicitReferenceConversionExists): Made public.
2224         (ImplicitReferenceConversionExists): Split out from
2225         StandardConversionExists.
2226
2227         * expression.cs (As): We were only implementing one of the three
2228         cases for the as operator.  We now implement them all.
2229         (Is): Implement the various other cases for Is as well.
2230
2231         * typemanager.cs (CACHE): New define used to control if we want or
2232         not the FindMembers cache.  Seems to have a negative impact on
2233         performance currently
2234
2235         (MemberLookup): Nested types have full acess to
2236         enclosing type members
2237
2238         Remove code that coped with instance/static returns for events, we
2239         now catch this in RealFindMembers.
2240
2241         (RealFindMembers): only perform static lookup if the instance
2242         lookup did not return a type or an event.
2243
2244 2002-05-17  Miguel de Icaza  <miguel@ximian.com>
2245
2246         * assign.cs (CompoundAssign): We pass more semantic information
2247         now to Compound Assignments than we did before: now we have all
2248         the information at hand, and now we resolve the target *before* we
2249         do the expression expansion, which allows the "CacheValue" method
2250         to have the effect we intended (before, a [x] += 1 would generate
2251         two differen ArrayAccess expressions from the ElementAccess,
2252         during the resolution process).
2253
2254         (CompoundAssign.DoResolve): Resolve target and original_source here.
2255
2256 2002-05-16  Miguel de Icaza  <miguel@ximian.com>
2257
2258         * expression.cs (ArrayAccess): dropped debugging information.
2259
2260         * typemanager.cs: Small bug fix: I was always returning i_members,
2261         instead of one of i_members or s_members (depending on which had
2262         the content).
2263
2264         * assign.cs (IAssignMethod.CacheTemporaries): New method.  This
2265         method is invoked before any code generation takes place, and it
2266         is a mechanism to inform that the expression will be invoked more
2267         than once, and that the method should use temporary values to
2268         avoid having side effects
2269
2270         (Assign.Emit): Call CacheTemporaries in the IAssignMethod.
2271
2272         * ecore.cs (Expression.CacheTemporaries): Provide empty default
2273         implementation.
2274
2275         * expression.cs (Indirection, ArrayAccess): Add support for
2276         CacheTemporaries in these two bad boys.
2277
2278         * ecore.cs (LoadFromPtr): figure out on our own if we need to use
2279         ldobj or ldind_ref.
2280         (StoreFromPtr): Handle stobj as well.
2281
2282         * expression.cs (UnaryMutator): Share more code.
2283
2284         * typemanager.cs (FindMembers): Thanks to Paolo for tracking this
2285         down: I was not tracking the Filter function as well, which
2286         was affecting the results of the cache.
2287
2288 2002-05-15  Miguel de Icaza  <miguel@ximian.com>
2289
2290         * attribute.cs: Remove the hack to handle the CharSet property on
2291         StructLayouts.
2292
2293 2002-05-14  Miguel de Icaza  <miguel@ximian.com>
2294
2295         * attribute.cs (DoResolve): More uglyness, we now only try to
2296         resolve the attribute partially, to extract the CharSet
2297         information (only if we are a StructLayout attribute).  Otherwise
2298
2299         (GetExtraTypeInfo): Add some code to conditionally kill in the
2300         future this.   I am more and more convinced that the .NET
2301         framework has special code to handle the attribute setting on
2302         certain elements.
2303
2304         * expression.cs (IsParamsMethodApplicable): Revert my previous
2305         foreach change here, it was wrong.
2306
2307 2002-05-13  Miguel de Icaza  <miguel@ximian.com>
2308
2309         * cs-tokenizer.cs: (pp_primary): Eat the ')' at the end.
2310         (pp_expr): do not abort on unknown input, just return.
2311         (eval): abort if there are pending chars.
2312
2313         * attribute.cs (Attribute.Resolve): Positional parameters are
2314         optional.  Deal with that case.
2315
2316         * class.cs (DefineType): Call Attribute.GetExtraTypeInfo to fetch
2317         the Ansi/Unicode/Auto information for the type.
2318
2319         (TypeContainer.DefineType): instantiate the EmitContext here, as
2320         we will be using it during the type definition (to resolve
2321         attributes) and during the emit phase.
2322
2323         * attribute.cs (Attribute.GetExtraTypeInfo): This routine is used
2324         to pull type information out of the attributes
2325
2326         (Attribute.Resolve): track the constructor builder, and allow for
2327         multiple invocations (structs and classes will use this).
2328
2329         * ecore.cs (MemberLookupFinal): new version with all the
2330         parameters customizable.
2331
2332         * expression.cs (New.DoResolve): Use MemberLookupFinal to locate
2333         constructors.  Return if the result value is null (as the error
2334         would have been flagged already by MemberLookupFinal)
2335
2336         Do not allow instances of abstract classes or interfaces to be
2337         created.
2338
2339         * class.cs: (MethodSignature.InheritableMemberSignatureCompare):
2340         We have to compare the assembly property here when dealing with
2341         FamANDAssem and Assembly access modifiers, because we might be
2342         creating an assembly from *modules* (that means that we are not
2343         getting TypeBuilders for types defined in other modules that are
2344         part of this assembly).
2345
2346         (Method.Emit): If the method is marked abstract and has a body,
2347         emit an error.
2348
2349         (TypeContainer.DefineMembers): If both the defined member and the
2350         parent name match are methods, then do not emit any warnings: let
2351         the Method.Define routine take care of flagging warnings.  But if
2352         there is a mismatch (method overrides something else, or method is
2353         overriwritten by something, then emit warning).
2354
2355         (MethodSignature.MemberSignatureCompare): If the sig.ret_type is
2356         set to null, this means `do not check for the return type on the
2357         signature'.
2358
2359         (Method.Define): set the return type for the method signature to
2360         null, so that we get methods with the same name and parameters and
2361         different return types.  This is used to flag warning 114 (you are
2362         hiding a method, and you probably want to use the new/override
2363         keywords instead).
2364
2365         * typemanager.cs (MemberLookup): Implemented proper access
2366         control, closing a long standing set of bug reports.  The problem
2367         was that the Framework only has two bits: Public and NonPublic,
2368         and NonPublic includes private and protected methods, but we need
2369         to enforce the FamANDAssem, FamOrAssem and Family.
2370
2371 2002-05-11  Miguel de Icaza  <miguel@ximian.com>
2372
2373         * statement.cs (GotoCase): Return true: Ammounts to giving up
2374         knowledge on whether we return or not, and letting the other case
2375         be responsible for it.
2376
2377 2002-05-10  Miguel de Icaza  <miguel@ximian.com>
2378
2379         * driver.cs: Do not load directories for each file processed, only
2380         do it if there is a pattern.
2381
2382         * ecore.cs: Report readonly assigns here as well, as we might have
2383         been resolved only by MemberAccess.
2384
2385         (SimpleName.SimpleNameResolve): Also be useful for LValue
2386         resolution.   We need this to propagate assign to local readonly variables
2387
2388         * typemanager.cs: Use a ptrhashtable for the criteria, because we
2389         do not want to reuse potential criteria memory.
2390
2391         * class.cs (MyEventBuilder): Set reflected_type;
2392
2393         * ecore.cs (Constantify): Added support for constifying bools.
2394
2395         (RootContext.LookupType): Added a cache for values looked up in
2396         the declaration space.
2397
2398         * typemanager.cs (FindMembers): Now is a front-end to
2399         RealFindMembers, and provides a two-level hashtable-based cache to
2400         the request.
2401
2402         15% performance improvement: from 22.5 to 19.2 seconds.
2403
2404         * expression.cs (IsParamsMethodApplicable): use foreach.
2405         (Invocation.DoResolve): ditto.
2406         (New.DoResolve): ditto.
2407         (ArrayCreation.DoResolve): ditto.
2408
2409         * ecore.cs (FindMostEncompassingType): use foreach.
2410
2411         * delegate.cs (NewDelegate.DoResolve): Use foreach
2412
2413         * ecore.cs (Expression.FindMostSpecificSource): Use foreach.
2414         (RemoveMethods): use foreach.
2415
2416         * expression.cs (Invocation.MakeUnionSet): Optimization: Use two
2417         nested foreach statements instead of for, and also break out of
2418         the inner loop once a match is found.
2419
2420         (Invocation.OverloadResolve): Use foreach, simplify the code.
2421
2422 2002-05-08  Miguel de Icaza  <miguel@ximian.com>
2423
2424         * cfold.cs (BinaryFold): During an enumeration evaluation context,
2425         we actually unwrap the expression to allow for extra information
2426         to be extracted.
2427
2428         * expression.cs: Use Shr_Un on unsigned operations.
2429
2430 2002-05-08  Ravi Pratap  <ravi@ximian.com>
2431
2432         * ecore.cs (FindMostEncompass*): Fix trivial bug where the set of
2433         applicable operators was not being considered correctly. This closes
2434         the bug Miguel reported.
2435
2436 Wed May 8 16:40:50 CEST 2002 Paolo Molaro <lupus@ximian.com>
2437
2438         * attribute.cs: check that the type derives from System.Attribute
2439         and report the correct error in that case (moved the duplicate code to
2440         its own method, too).
2441
2442 Wed May 8 11:50:31 CEST 2002 Paolo Molaro <lupus@ximian.com>
2443
2444         * attribute.cs: lookup attribute type name as the spec says: first the
2445         bare attribute name and then name + "Attribute" (nant compiles with
2446         mcs after this fix).
2447
2448 2002-05-07  Miguel de Icaza  <miguel@ximian.com>
2449
2450         * expression.cs (Unary.TryReduceNegative): Ah!  Tricky!  Tricky!
2451         Because of the way we parse things, we should try to see if a
2452         UIntConstant can fit in an integer.
2453
2454 2002-05-07  Ravi Pratap  <ravi@ximian.com>
2455
2456         * ecore.cs (GetConversionOperators): Do not pick up op_True operators
2457         when we are in an explicit context.
2458
2459         (ConvertReferenceExplicit): When converting from Iface type S to Class
2460         T make sure the rules are implemented as an OR.
2461
2462         * parameter.cs (ParameterType): Make it a property for now although the
2463         purpose really isn't anything immediate.
2464
2465         * expression.cs (Is*Applicable): Do better checking on the parameter type
2466         of a ref/out parameter. The ones from the system assemblies are already
2467         marked with the correct type so we don't need to do any correction.
2468
2469         * ecore.cs (StandardConversionExists): Conversion from Interface types to
2470         the object type is standard too so include that.
2471
2472 2002-05-06  Miguel de Icaza  <miguel@ximian.com>
2473
2474         * ecore.cs (StandardConversionExists): Augment with missing code:
2475         deal with IntConstant, LongConstants and Enumerations.
2476
2477         * assign.cs: Report the error, instead of failing silently
2478
2479         * rootcontext.cs (AddGlobalAttributes): Track attributes on the
2480         typecontainer that they are declared, because the
2481         typecontainer/namespace will have the list of using clauses that
2482         need to be applied.
2483
2484         Assembly Attributes were escaping the normal registration
2485         mechanism.
2486
2487         (EmitCode): Apply attributes within an EmitContext that represents
2488         the container they were declared on.
2489
2490         * cs-parser.jay: Track bases for structs.  How did I get this wrong?
2491
2492 2002-05-06  Ravi Pratap  <ravi@ximian.com>
2493
2494         * ecore.cs (FindMostEncompassingType, FindMostEncompassedType):
2495         Revamp completely - make much cleaner as we now operate only
2496         on a set of Types.
2497
2498         (FindMostSpecificSource, FindMostSpecificTarget): New methods
2499         to implement the logic detailed in the spec more correctly.
2500
2501         (UserDefinedConversion): Update accordingly.
2502
2503 2002-05-06  Miguel de Icaza  <miguel@ximian.com>
2504
2505         * statement.cs: Return flow analysis information up.
2506
2507         * cs-tokenizer.cs (adjust_real): Share code between LITERAL_DOUBLE
2508         and the default.
2509
2510         (token): Do not consume an extra character before calling
2511         decimal_digits.
2512
2513 2002-05-06  Piers Haken <piersh@friskit.com>
2514
2515         * cs-parser.jay: add 'override' attribute to System.Object.Finalize
2516
2517 2002-05-06  Miguel de Icaza  <miguel@ximian.com>
2518
2519         * class.cs (Constructor.Emit): Set the IsStatic flag in the
2520         EmitContext during the instance constructor initializer
2521         resolution, to stop access to instance variables.
2522
2523         This is mandated by the spec, last paragraph of the `constructor
2524         initializers' section.
2525
2526 2002-05-05  Miguel de Icaza  <miguel@ximian.com>
2527
2528         * cs-parser.jay, class.cs (Accessor): new class used to represent
2529         an accessor (get or set).  In the past we used `null' to represent
2530         a missing accessor.  But this is ambiguous because there was no
2531         way to tell in abstract indexers/properties if one of them was
2532         specified.
2533
2534         Now there is a way of addressing that.
2535
2536         * expression.cs (Indexers.GetIndexersForType): Use TypeManager.MemberLookup
2537         instead of FindMembers.
2538
2539         * class.cs (TypeContainer.EmitFieldInitializer): Do not typecast
2540         the result of Assign.Resolve as Assign, but rather as ExpressionStatement.
2541
2542         * attribute.cs: Treat indexers and properties as the same in terms
2543         of applying attributes
2544
2545         * ecore.cs (FindMostEncompassedType): Use statically initialized
2546         EmptyExpressions()s like we do elsewhere to avoid creating useless
2547         objects (and we take this out of the tight loop).
2548
2549         (GetConversionOperators): Move the code to extract the actual
2550         operators to a separate routine to clean things up.
2551
2552 2002-05-04  Miguel de Icaza  <miguel@ximian.com>
2553
2554         * ecore.cs (FieldExpr): Remove un-needed tests for null, since now
2555         events are always registered FieldBuilders.
2556
2557         * class.cs (FieldBase): New class shared by Fields
2558
2559         * delegate.cs: If we are a toplevel delegate, use our full name.
2560         If we are a nested delegate, then only use our tail name.
2561
2562 2002-05-02  Ravi Pratap  <ravi@ximian.com>
2563
2564         * expression.cs (IsApplicable): Ensure that we add the "&" to
2565         ref/out types before comparing it with the type of the argument.
2566
2567         (IsParamsMethodApplicable): Ditto.
2568
2569         (Argument.Type): Use TypeManager.LookupType instead of Type.GetType -
2570         silly me ;-)
2571
2572         * delegate.cs : Handle the case when we have more than one applicable
2573         method. Flag an error only when we finish checking all.
2574
2575 2002-05-02  Miguel de Icaza  <miguel@ximian.com>
2576
2577         * expression.cs: Add support for boolean static initializers.
2578
2579 2002-05-01  Miguel de Icaza  <miguel@ximian.com>
2580
2581         * attribute.cs: Use proper cast for Events, since we use a MyEventBuilder.
2582
2583         * parameter.cs (ComputeParameterTypes,
2584         ComputeAndDefineParameterTypes): Better error handling: now we
2585         clear the `types' cache if we fail during any of the type lookups.
2586         We also return the status code correctly to our caller
2587
2588         * delegate.cs: If we fail to define a delegate, abort the extra
2589         steps.
2590
2591         * expression.cs (Binary.ResolveOperator): for
2592         operator==(object,object) and operator !=(object, object) we also
2593         have to verify that there is an implicit conversion from one to
2594         the other.
2595
2596         (ArrayAccess.DoResolve): Array Access can operate on
2597         non-variables.
2598
2599 2002-04-30  Miguel de Icaza  <miguel@ximian.com>
2600
2601         * assign.cs (CompoundAssign): A new class used as a "flag" that
2602         the assignment actually is happening as part of a compound
2603         assignment operator.
2604
2605         During compound assignment, a few new rules exist to enable things
2606         like:
2607
2608         byte b |= 1 + 2
2609
2610         From the spec:
2611
2612         x op= y can be evaluated as x = (T) (x op y) (ie, an explicit cast
2613         to the type of x) if y is implicitly convertible to the type of x,
2614         and the operator is a builtin operator and the return type of the
2615         operator is explicitly convertible to the type of x.
2616
2617         * rootcontext.cs: Reset warning level to 2.  4 catches various
2618         "interesting" features in mcs, we must clean this up at some
2619         point, but currently am trying to kill other bugs ;-)
2620
2621         * ecore.cs (SimpleName.SimpleNameResolve): Perform member lookups
2622         in container classes as well.
2623
2624         * expression.cs (Binary.ResolveOperator): Handle string case
2625         before anything else (as operator overloading does emit an error
2626         before doing anything else).
2627
2628         This code could go away when we move to a table driven model, but
2629         i could not come up with a good plan last night.
2630
2631 2002-04-30  Lawrence Pit <loz@cable.a2000.nl>
2632
2633         * typemanager.cs (CSharpName): reimplementation using regex.
2634         * class.cs: added null check for fields in Emit
2635         * rootcontext.cs: set warninglevel to 4
2636
2637 2002-04-29  Miguel de Icaza  <miguel@ximian.com>
2638
2639         * typemanager.cs (CSharpName): reimplemented with Lupus
2640         suggestion.
2641
2642 2002-04-28  Miguel de Icaza  <miguel@ximian.com>
2643
2644         * statement.cs (If): correclty implement Resolve, because we were
2645         not catching sem errors in there.  The same process is needed
2646         everywhere else.
2647         (Return, StatementExpression, For, While, Do, Throw, Lock): Implement Resolve
2648
2649
2650         (Statement.Warning_DeadCodeFound): Factorize code.
2651         (While): Report dead code here too.
2652
2653         (Statement): Added Resolve virtual method to allow
2654         for resolution split from the emit code.
2655
2656 2002-04-26  Miguel de Icaza  <miguel@ximian.com>
2657
2658         * statement.cs (EmitBoolExpression): No longer try to resolve the
2659         expression here.
2660         (MakeBoolean): New utility function that resolve, implicitly
2661         converts to boolean and tags the expression.
2662
2663
2664         (If, Do): Implement dead code elimination.
2665         (While): Implement loop inversion
2666
2667         (Do, While, For, If): Resolve the expression prior to calling our
2668         code generation.
2669
2670 2002-04-22  Lawrence Pit <loz@cable.a2000.nl>
2671
2672         * class.cs:
2673           - added method Report28 (warning: program has more than one entry point)
2674           - added method IsEntryPoint, implements paragraph 10.1 of the spec
2675           - modified method Method.Define, the part at the end of the method
2676
2677         * rootcontext.cs: added static public Location EntryPointLocation;
2678
2679         * ../errors/cs0028.cs : Add test case for the above warning.
2680
2681         * typemanager.cs:
2682           - modified method CSharpName to allow arrays of primitive type to
2683             be printed nicely (e.g. instead of System.Int32[][] it now prints
2684             int[][])
2685           - added method CSharpSignature: returns the signature of a method
2686             in string format to be used in reporting errors, warnings, etc.
2687
2688         * support.cs: InternalParameters.ParameterDesc variable tmp initialized
2689         with String.Empty.
2690
2691 2002-04-26  Ravi Pratap  <ravi@ximian.com>
2692
2693         * delegate.cs (Define): Fix extremely silly bug where I was
2694         setting the type of the 'object' parameter of the BeginInvoke
2695         method to System.IAsyncResult instead of System.Object ;-)
2696
2697 2002-04-26  Miguel de Icaza  <miguel@ximian.com>
2698
2699         * class.cs (ConstructorInitializer.Resolve): Also use DeclaredOnly
2700         here.
2701
2702         (Constructor.Emit): return if we fail to initialize the
2703         constructor.  Another door closed!
2704
2705         * expression.cs (New.DoResolve): Improve error message (from -6 to
2706         1501).  Use DeclaredOnly lookup to find the exact constructor.
2707
2708         * typemanager.cs (MemberLookup): If DeclaredOnly is set, do not
2709         loop.  This is useful.
2710
2711         * cs-parser.jay: Adjust the default parameters so that destructors
2712         have the proper signature.
2713
2714 2002-04-26  Martin Baulig  <martin@gnome.org>
2715
2716         * driver.cs (LoadAssembly): If `assembly' contains any characters
2717         which are only valid in path names and not in assembly names
2718         (currently slash, backslash and point), use Assembly.LoadFrom ()
2719         instead of Assembly.Load () on the `assembly' (before iteration
2720         over the link_paths).
2721
2722 2002-04-26  Martin Baulig  <martin@gnome.org>
2723
2724         * cs-tokenizer.cs (is_hex): Correctly handle lowercase chars.
2725
2726 2002-04-25  Miguel de Icaza  <miguel@ximian.com>
2727
2728         * class.cs (Property): use the new typemanager.MemberLookup
2729
2730         (TypeContainer.MemberLookup): Implement using the
2731         TypeManager.MemberLookup now.
2732
2733         * typemanager.cs: Make MemberLookup a function of the TypeManager,
2734         and return MemberInfos, so that these can be used without an
2735         EmitContext (what we had before).
2736
2737 2002-04-24  Miguel de Icaza  <miguel@ximian.com>
2738
2739         * expression.cs: Fix the case where the argument to params if the
2740         type of the params.  I omitted handling this before.   Fixed
2741
2742 2002-04-22  Miguel de Icaza  <miguel@ximian.com>
2743
2744         * driver.cs: Call BootCorlib_PopulateCoreType
2745
2746         * class.cs (Property.CheckBase): Check for properties only, not
2747         for all members.
2748
2749         * interface.cs: Temporary hack: try/catch around the
2750         CustomAttributeBuilder, because I am getting an exception that I
2751         do not understand.
2752
2753         * rootcontext.cs (BootCorlib_PopulateCoreType): Populate some
2754         types whose definitions are required to be there (attributes are
2755         defined before standard types).
2756
2757         Compute definitions as we boot the various types, as they are used
2758         immediately (value_type class will need object_type, but if we do
2759         not initialize object_type, we will pass a null, which will let
2760         the runtime pick the System.Object from the existing corlib, which
2761         is not what we want).
2762
2763 2002-04-22  Patrik Torstensson <totte@labs2.com>
2764
2765         * cs-tokenizer.cs: fixed a number of trim() issues.
2766
2767 2002-04-22  Ravi Pratap  <ravi@ximian.com>
2768
2769         * expression.cs (Argument.Type): Ensure that we return the correct
2770         type when we have out or ref parameters [in which case we
2771         append a "&"].
2772
2773 2002-04-22  Miguel de Icaza  <miguel@ximian.com>
2774
2775         * class.cs (Property, Indexer): Allow extern modifier in there.
2776
2777         * typemanager.cs (InitBaseTypes): Initializes object_type and
2778         value_type, since those will be used early on during the bootstrap
2779         process to compile corlib.
2780
2781         (InitCoreTypes): Move code from here to InitBaseTypes.
2782
2783 2002-04-21  Miguel de Icaza  <miguel@ximian.com>
2784
2785         * ecore.cs (PropertyExpr): Optimize calls to Array::get_Length on
2786         single-dimension arrays as using the ldlen opcode.
2787
2788         Daniel Lewis discovered this optimization.
2789
2790         * typemanager.cs: Add signature for System.Array::get_Length
2791
2792 2002-04-20  Gonzalo Paniagua Javier <gonzalo@ximian.com>
2793
2794         * statement.cs: report the error when the foreach does not apply to an
2795         array nor a collection.
2796
2797 2002-04-19  Miguel de Icaza  <miguel@ximian.com>
2798
2799         * expression.cs: Add implicit conversions to the operator ~.
2800
2801         * constant.cs (DecimalConstant.Emit): Emit decimal value.
2802
2803         * typemanager.cs: Locate the decimal constructor.
2804
2805 2002-04-17  Gonzalo Paniagua Javier <gonzalo@ximian.com>
2806
2807         * attribute.cs: use the new property of TypeOf.
2808         * expression.cs: added 'get' property around typearg.
2809
2810         These changes fix a build breaker reported by NickD. Is this the
2811         correct way to fix?  If not, please, revert my changes and make it
2812         work :-).
2813
2814 2002-04-17  Miguel de Icaza  <miguel@ximian.com>
2815
2816         * attribute.cs: Add support for typeof in attribute invocations.
2817         I am not sure that this is right though.
2818
2819 2002-04-14  Duncan Mak  <duncan@ximian.com>
2820
2821         * cfold.cs (BinaryFold): Catch DivideByZeroException in the
2822         Binary.Operator.Division case.
2823
2824 2002-04-13  Ravi Pratap  <ravi@ximian.com>
2825
2826         * class.cs (DefineType): Ensure that we do a proper check on
2827         attribute types and also register it with the TypeManager.
2828
2829         (TypeContainer.Targets): The default for attribute types is
2830         AttributeTargets.All.
2831
2832         * attribute.cs (ApplyAttributes): Registering the attribute type
2833         is done elsewhere, not when we discover we have a Usage attribute.
2834
2835 2002-04-12  Ravi Pratap  <ravi@ximian.com>
2836
2837         * expression.cs (VerifyArgumentsCompat): Implement Miguel's suggestion
2838         and get rid of is_delegate parameter.
2839
2840         * everywhere : update.
2841
2842 2002-04-12  Ravi Pratap  <ravi@ximian.com>
2843
2844         * cs-parser.jay (compilation_unit): Revamp completely to use
2845         some new ideas that I got from Rhys' grammar to solve the problems
2846         with assembly level attributes.
2847
2848         (outer_declaration): New grammar production.
2849
2850         (attribute_sections): Add.
2851
2852         (opt_attributes): Base on attribute_sections
2853
2854         (namespace_declaration): Allow opt_attributes to tackle the case
2855         when we have assembly level attributes - we are clever in this
2856         regard now ;-)
2857
2858         * attribute.cs (ApplyAttributes): Do not worry about assembly
2859         attributes in the non-global context.
2860
2861         * rootcontext.cs (AddGlobalAttributes): Go back to using this
2862         instead of SetGlobalAttributes.
2863
2864         * class.cs, rootcontext.cs : Ensure we define and generate
2865         attribute types before anything else.
2866
2867         * attribute.cs (CheckAttribute and GetValidPlaces): Handle the exception
2868         and flag the new error -20 for the case when the attribute type
2869         does not have valid targets specified. csc does not catch this.
2870
2871         * ../errors/errors.txt : update for error # -20
2872
2873 2002-04-11  Ravi Pratap  <ravi@ximian.com>
2874
2875         * support.cs (InternalParameters.ParameterModifier): Do some null
2876         checking and return sane values.
2877
2878         * class.cs (Method.Define): If we are a PInvoke method, ensure
2879         that we are static and extern. Report error # 601
2880
2881         * ../errors/cs0601.cs : Add test case for the above error.
2882
2883 2002-04-07  Ravi Pratap  <ravi@ximian.com>
2884
2885         * rootcontext.cs (attribute_types): We need to keep type of
2886         all attribute types separately and emit code for them first.
2887
2888         (RegisterAttribute) : Implement.
2889
2890         * class.cs (DefineType): Check if the current Type is a custom
2891         attribute type and register it accordingly.
2892
2893         * rootcontext.cs (AddGlobalAttributes): Fix silly bug where we were
2894         adding the first attribute twice and rename to
2895
2896         (SetGlobalAttributes): this.
2897
2898         * rootcontext.cs (NamespaceLookup): Run through the aliases too and perform
2899         lookups.
2900
2901         * attribute.cs (ApplyAttributes): Take an additional argument telling us
2902         if we are processing global arguments. Hmm, I am unsure of this.
2903
2904 2002-04-12  Gonzalo Paniagua Javier <gonzalo@ximian.com>
2905
2906         * expression.cs: added static array of strings to avoid calling
2907         Enum.ToString () for Operator in Binary. Significant recover of
2908         performance.
2909
2910 2002-04-10  Miguel de Icaza  <miguel@ximian.com>
2911
2912         * class.cs (FindMembers): Allow the Builders of the various
2913         members to be null.  If they are skip them.  This only happens
2914         during the PInvoke declaration.
2915
2916 2002-04-09  Miguel de Icaza  <miguel@ximian.com>
2917
2918         * parameter.cs (Parameters.ComputeParameterTypes): Flag the
2919         failure, so we do not keep going afterwards.
2920
2921         * expression.cs: (Invocation.OverloadResolve): I believe Ravi
2922         wanted to pass `false' as the `is_delegate' argument.  If this is
2923         the case, why not use delegate_type == null to mean `is_delegate =
2924         false' and anything else as is_delegate = true.
2925
2926 Tue Apr  9 05:40:12  2002 Piers Haken <piersh@friskit.com>
2927
2928         * statement.cs: fixed SimpleSwitchEmit to make 'goto case' goto the
2929         code for the section, not the beginning of the tests.
2930
2931 2002-04-08  Miguel de Icaza  <miguel@ximian.com>
2932
2933         * cfold.cs: Handle operator + (Enum x, Underlying x)
2934
2935         * expression.cs (Binary): same.  Warn about errors where we have
2936         Enum/Enum in operator + as well.
2937
2938 Mon Apr  8 06:29:03  2002 Piers Haken <piersh@friskit.com>
2939
2940         * statement.cs:
2941                 - added support for switch(bool)
2942                 - optimize loading of I8/U8 constants (ldc.i4, iconv_i8)
2943                 - add TableSwitchEmit() to handle table-based switch statements
2944
2945 2002-04-05  Ravi Pratap  <ravi@ximian.com>
2946
2947         * expression.cs (Invocation.OverloadResolve): Factor out code which
2948         does parameter compatibility checking with arguments so that we can
2949         re-use the code even from Delegate.VerifyApplicability
2950
2951         (VerifyArgumentsCompat): Move above code here.
2952
2953         * delegate.cs (VerifyApplicability): Get rid of duplicate code
2954         and instead make a call to the above method.
2955
2956 2002-03-31  Ravi Pratap  <ravi@ximian.com>
2957
2958         * typemanager.cs (attribute_type): Corresponds to System.Attribute.
2959         We use it to keep track of classes which are attribute types.
2960
2961 2002-04-02  Miguel de Icaza  <miguel@ximian.com>
2962
2963         * delegate.cs (Delegate.Define): Correctly define the types in the
2964         presence of fixed and array parameters.
2965
2966         * class.cs (TypeContainers.FindMembers): Use NonPublic flag while
2967         doing FindMembers.
2968
2969         * ecore.cs (Expression.MemberLookup): Reset binding flags to not
2970         include NonPublic after the first iteration.
2971
2972         * class.cs (Indexer.CheckBase): Only check if both parents are
2973         non-null.
2974
2975         * cs-parser.jay (accessor_body): If empty, set to null.
2976
2977         * ecore.cs (SimpleName.SimpleNameResolve): We did not have the
2978         same code path here to resolve constants names that we did have in
2979         MemberAccess.DoResolve.  There is too much code duplicated here.
2980
2981 2002-04-01  Miguel de Icaza  <miguel@ximian.com>
2982
2983         * statement.cs, makefile: Drop Statementcollection and just use ArrayLists
2984
2985         * ecore.cs: Optimize UserDefinedConversion by minimizing the calls
2986         to MakeUnionSet.
2987
2988         * cs-tokenizer.cs: Reuse a single StringBuilder for assembling
2989         tokens, numbers and strings.
2990
2991         * ecore.cs (MethodGroupExpr): Make Emit warn about missing
2992         parenthesis.
2993
2994         * delegate.cs: Use ComputeAndDefineParameterTypes for both the
2995         asyncronous parameters and the regular parameters.
2996
2997         * codegen.cs (CodeGen.Init): Use the constructor that allows us to
2998         specify the target directory.
2999
3000         * expression.cs: (This.DoResolve): Simplify
3001         (As.Emit): Optimize, do not generate IsInst if the expression is
3002         always of the given type.
3003
3004         (Is.DoResolve): Bug fix, we were reporting both always/never for
3005         the is expression.
3006
3007         * (Invocation.MakeUnionSet): Simplify vastly and optimize, we were
3008         creating too many unnecessary arrays.
3009
3010 2002-03-31  Miguel de Icaza  <miguel@ximian.com>
3011
3012         * class.cs (EmitFieldInitializer): Use Assign expression to assign
3013         fields instead of rolling our own initializer.   Takes care of all
3014         implicit conversions, and drops unnecessary static checks/argument.
3015
3016 2002-03-31  Dick Porter  <dick@ximian.com>
3017
3018         * driver.cs: use the GetDirectories() return values properly, and
3019         use "/" as path separator.
3020
3021 2002-03-30  Miguel de Icaza  <miguel@ximian.com>
3022
3023         * expression.cs (Unary): Optimize - - expr into expr.
3024         (Binary): Optimize a + (-b) into a -b.
3025
3026         * codegen.cs (CodeGen): Made all methods static.
3027
3028 2002-03-29  Miguel de Icaza  <miguel@ximian.com>
3029
3030         * rootcontext.cs:
3031
3032         * decl.cs: Rename `definition' into `TypeBuilder' and drop the
3033         TypeBuilder property.
3034
3035         * cs-parser.jay: Drop the use of RecordXXX and use RecordDecl
3036         instead.
3037
3038         * tree.cs: Removed the various RecordXXXX, and replaced with a
3039         single RecordDecl.  Removed all the accessor methods, and just
3040         left a single access point Type
3041
3042         * enum.cs: Rename DefineEnum to DefineType.
3043
3044         * decl.cs: New abstract method `DefineType' used to unify the
3045         Defines for Enumerations, Interfaces, TypeContainers and
3046         Delegates.
3047
3048         (FindType): Moved LookupInterfaceOrClass here.  Moved the
3049         LookupBaseClasses method that used to live in class.cs and
3050         interface.cs here, and renamed to FindType.
3051
3052         * delegate.cs: Implement DefineType.  Take advantage of the
3053         refactored pattern for locating the parent builder without taking
3054         the parent_builder argument (which we know does not work if we are
3055         nested, and triggering a toplevel definition).
3056
3057 2002-03-28  Miguel de Icaza  <miguel@ximian.com>
3058
3059         * decl.cs (MemberCore.CheckMethodAgainstBase): Test if the
3060         accessibility of a member has changed during override and report
3061         an error if so.
3062
3063         * class.cs (Method.Define, Property.Define): Only complain on
3064         overrides if the method is private, any other accessibility is
3065         fine (and since we just checked the permission is the same, we are
3066         good to go).
3067
3068         * cs-tokenizer.cs: only line, region, endregion, if, endif, else
3069         and elif are processed always.  The other pre-processing
3070         directives are only processed if we are "taking" the path
3071
3072 2002-03-29  Martin Baulig  <martin@gnome.org>
3073
3074         * class.cs (Method.Emit): Only emit symbolic debugging info if the
3075         current location is not Null.
3076
3077         * codegen.cs (CodeGen.SaveSymbols): Split out symbol writing code into
3078         a separate method so we can profile it.
3079
3080         * driver.cs (ShowTime): We need to use `(int) span.TotalSeconds' since
3081         `span.Seconds' are just seconds, but no minutes or hours.
3082         (MainDriver): Profile the CodeGen.SaveSymbols calls.
3083
3084 2002-03-28  Miguel de Icaza  <miguel@ximian.com>
3085
3086         * class.cs (Method.Define), (Property.Define), (Indexer.Define):
3087         Remove the gratuitous set of Final:
3088
3089                                 // If an interface implementation, then we can set Final.
3090                                 if (((flags & MethodAttributes.Abstract) == 0) &&
3091                                     implementing.DeclaringType.IsInterface)
3092                                         flags |= MethodAttributes.Final;
3093
3094         I do not know what I was smoking when I used that.
3095
3096
3097         * cs-parser.jay, delegate.cs: Make Delegate be a DeclSpace, first
3098         step into fixing the name resolution issues for delegates and
3099         unifying the toplevel name resolution.
3100
3101 2002-03-28  Martin Baulig  <martin@gnome.org>
3102
3103         * class.cs (Method.Emit): If we have a symbol writer, call its
3104         OpenMethod(), CloseMethod() and SetMethodSourceRange() methods to
3105         tell it about the current method.
3106
3107         * codegen.cs (EmitContext.Mark): New public method. Tell the symbol
3108         writer that we're going to emit the first byte of IL code for a new
3109         statement (a new source line).
3110         (EmitContext.EmitTopBlock): If we have a symbol writer, call
3111         EmitContext.Mark() before emitting any code.
3112
3113         * location.cs (SymbolDocument): Return null when we're Null.
3114
3115         * statement.cs (Statement): Moved the `Location loc' variable here.
3116         (Statement.EmitBoolExpression): If we have a symbol writer, call
3117         ec.Mark() before emitting any code to tell it that we're at the
3118         beginning of a new statement.
3119         (StatementExpression): Added `Location' argument to the constructor.
3120         (Block): Added public readonly variable `StartLocation' and public
3121         variable `EndLocation'.  The latter is to be set using SetEndLocation().
3122         (Block): Added constructor which takes a start and end location.
3123         (Block.SetEndLocation): New method. This sets the end location.
3124         (Block.EmitMeta): If we have a symbol writer, tell it the names of the
3125         local variables we create.
3126         (Block.Emit): If we have a symbol writer, call ec.Mark() before emitting
3127         each statement and do also mark the begin and end of the block.
3128
3129         * cs-parser.jay (block : OPEN_BRACE): Use the new `Block' constructor to
3130         tell it the current lexer.Location, use Location.Null for the end of the
3131         block.
3132         (block : OPEN_BRACE opt_statement_list CLOSE_BRACE): When closing the
3133         current block, set its end location using SetEndLocation().
3134         (statement_expression): StatementExpression constructor now takes the
3135         lexer.Location as additional argument.
3136         (for_statement, declare_local_variables): Likewise.
3137         (declare_local_variables): When creating a new implicit block, use the
3138         new Block constructor and pass it the lexer.Location.
3139
3140 2002-03-28  Miguel de Icaza  <miguel@ximian.com>
3141
3142         * ecore.cs (Expression.MemberLookup): On interfaces, lookup
3143         members also on the parent interfaces recursively.
3144
3145 2002-03-27  Miguel de Icaza  <miguel@ximian.com>
3146
3147         * report.cs: Use new formats, since Gonzalo finished the missing
3148         bits.
3149
3150         * expression.cs (Binary.ResolveOperator): added missing operator|
3151         operator& and operator^ for bool/bool.
3152
3153         * cs-parser.jay: CheckDef now takes a Location argument that is
3154         used to report errors more precisly (instead of reporting the end
3155         of a definition, we try to track something which is a lot closer
3156         to the source of the problem).
3157
3158         * cs-tokenizer.cs: Track global token use, so we can properly flag
3159         the use of #define/#undef after the first token has been seen.
3160
3161         Also, rename the reportXXXX to Error_DescriptiveName
3162
3163         * decl.cs (DeclSpace.IsTopLevel): Move property here from
3164         TypeContainer, so that Enum and Interface can use this too.
3165
3166         * class.cs (TypeContainer.LookupInterfaceOrClass,
3167         GetInterfaceOrClass, GetClassBases, DefineType): Drop the
3168         `builder' argument.  Typically this was used to pass the parent
3169         builder (a ModuleBuilder or a TypeBuilder from whoever triggered
3170         the definition).
3171
3172         The problem is that a nested class could trigger the definition of
3173         a toplevel class, and the builder would be obviously wrong in that
3174         case.
3175
3176         So we drop this argument, and we compute dynamically the
3177         TypeBuilder/ModuleBuilder (the correct information was available
3178         to us anyways from DeclSpace.Parent)
3179
3180         * interface.cs (Interface.DefineInterface): Drop builder
3181         parameter cleanup like class.cs
3182
3183         * enum.cs (Enum.DefineEnum): Drop builder parameter.  Clean up
3184         like class.cs
3185
3186         * statement.cs (Switch.EmitObjectInteger): Emit short/ushort
3187         values.
3188
3189         (Try.Emit): Propagate the returns value from the statement.
3190
3191         (Return.Emit): Even if we are leavning
3192
3193         * driver.cs: Catch IOExpcetion for Directory.GetFiles as well.
3194
3195         * modifiers.cs: Fix the computation of MethodAttributes flags.
3196
3197 Tue Mar 26 21:14:36 CET 2002 Paolo Molaro <lupus@ximian.com>
3198
3199         * driver.cs: allow compilation of files that start with '/'.
3200         Add a default case when checking the argument of --target.
3201
3202 2002-03-25  Miguel de Icaza  <miguel@ximian.com>
3203
3204         * interface.cs: Implement the same search algorithm for types in
3205         the interface code.
3206
3207         * delegate.cs: Do not allow multiple definition.
3208
3209         * Recovered ChangeLog that got accidentally amputated
3210
3211         * interface.cs (Interface.DefineInterface): Prevent from double definitions.
3212
3213         * rootcontext.cs: Load manually enum to allow core classes to
3214         contain enumerations.
3215
3216         * enum.cs, ecore.cs, driver.cs, attribute.cs, class.cs, expression.cs:
3217         Update to new static methods in TypeManager.
3218
3219         * typemanager.cs (GetMethod, GetConstructor): Use our
3220         implementation of FindMembers to find the members, since during
3221         corlib compilation, the types are TypeBuilders and GetMethod and
3222         GetConstructor do not work.
3223
3224         Make all methods in TypeManager static.
3225
3226         (InitCodeHelpers): Split the functionality from
3227         the InitCodeTypes function.
3228
3229         * driver.cs: Call InitCodeHelpers after we have populated the
3230         types.
3231
3232         * cs-parser.jay (delegate_declaration): we did not used to compute
3233         the delegate name correctly for void delegates.
3234
3235 2002-03-24  Miguel de Icaza  <miguel@ximian.com>
3236
3237         * rootcontext.cs (RootContext): Init the interface_resolve_order
3238         and type_container_resolve_order always.
3239
3240         (ResolveCore, BootstrapCorlib_ResolveClass,
3241         BootstrapCorlib_ResolveStruct): New functions to bootstrap the
3242         compiler when compiling with --nostdlib
3243
3244         * class.cs (TypeContainer.DefineType): Check that our parent is
3245         not null.  This test is most important when we are bootstraping
3246         the core types.
3247
3248         * codegen.cs: Split out the symbol writing code.
3249
3250 2002-03-25  Martin Baulig  <martin@gnome.org>
3251
3252         * driver.cs (-g): Made -g an alias for --debug.
3253
3254 2002-03-24  Martin Baulig  <martin@gnome.org>
3255
3256         * codegen.cs (SymbolWriter): New public variable. Returns the
3257         current symbol writer.
3258         (CodeGen): Added `bool want_debugging_support' argument to the
3259          constructor. If true, tell the ModuleBuild that we want debugging
3260         support and ask it for the ISymbolWriter.
3261         (Save): If we have a symbol writer, call it's Close() method after
3262         saving the assembly.
3263
3264         * driver.c (--debug): New command line argument to create a
3265         debugger information file.
3266
3267         * location.cs (SymbolDocument): New public property. Returns an
3268         ISymbolDocumentWriter object for the current source file or null
3269         if we don't have a symbol writer.
3270
3271 2002-03-21  Miguel de Icaza  <miguel@ximian.com>
3272
3273         * driver.cs (LoadAssembly): Correctly return when all the paths
3274         have been tried and not before.
3275
3276         * statement.cs (Switch.Emit): return the actual coverage for this
3277         statement (returns/not-returns)
3278
3279         (Switch.SimpleSwitchEmit): Do not generate jumps to the end of the
3280         switch of the statement if we are the last switch section.  That
3281         kills two problems: try/catch problems (we used to emit an empty
3282         nop at the end) and switch statements where all branches would
3283         return.
3284
3285 2002-03-19  Miguel de Icaza  <miguel@ximian.com>
3286
3287         * driver.cs: Add default assemblies (the equivalent to the
3288         Microsoft CSC.RSP file)
3289
3290         * cs-tokenizer.cs: When updating `cols and setting it to zero,
3291         also update tokens_seen and set it to false.
3292
3293         * driver.cs: Implement --recurse for Mike.
3294
3295         * driver.cs (SplitPathAndPattern): Small bug fix, I was not
3296         correctly splitting out the paths.
3297
3298 2002-03-18  Miguel de Icaza  <miguel@ximian.com>
3299
3300         * interface.cs (Interface.PopulateProperty): Instead of using
3301         `parent' as the declaration space for the set parameters, use
3302         `this'
3303
3304         * support.cs (InternalParameters): InternalParameters constructor
3305         takes a DeclSpace instead of a TypeContainer.
3306
3307         * expression.cs (ArrayCreation.EmitDynamicInitializers): If value
3308         types are being initialized, load the address of it before calling
3309         the function.
3310
3311         (New): Provide a mechanism to disable the generation of local
3312         value type temporaries when the caller will be providing us with
3313         an address to store it.
3314
3315         (ArrayCreation.EmitDynamicInitializers): Use it.
3316
3317 2002-03-17  Miguel de Icaza  <miguel@ximian.com>
3318
3319         * expression.cs (Invocation.EmitArguments): Only probe for array
3320         property if there is more than one argument.  Sorry about that.
3321
3322         * class.cs (Invocation.EmitArguments): Fix to emit arguments for
3323         empty param arrays.
3324
3325         * class.cs (Method.LabelParameters): Fix incorrect code path that
3326         prevented the `ParamArrayAttribute' from being applied to the
3327         params attribute.
3328
3329 2002-03-16  Miguel de Icaza  <miguel@ximian.com>
3330
3331         * support.cs (ReflectionParameters): Correctly compute whether the
3332         last argument is a params array.  Fixes the problem with
3333         string.Split ('a')
3334
3335         * typemanager.cs: Make the assemblies array always be non-null
3336         (empty, but non-null)
3337
3338         * tree.cs (RecordDecl): New function that abstracts the recording
3339         of names.  This reports error 101, and provides a pointer to the
3340         previous declaration.  Fixes a crash in the compiler.
3341
3342         * cs-parser.jay (constructor_declaration): Update to new grammar,
3343         and provide a constructor_body that can be empty.
3344
3345 2002-03-15  Miguel de Icaza  <miguel@ximian.com>
3346
3347         * driver.cs: Add support for --resources.
3348
3349         * expression.cs: (FetchGetMethod, FetchAddressMethod, EmitAssign):
3350         Make all types for the various array helper methods be integer.
3351
3352         * ecore.cs (Expression.ConvertNumericExplicit): Pass the
3353         CheckState to ConvCast.
3354
3355         (ConvCast): Now it takes a `checked' state argument, to avoid
3356         depending on the emit context for the conversion, and just using
3357         the resolve time setting.
3358
3359         * expression.cs (ArrayCreation.EmitArrayArguments): New function,
3360         instead of Invocation.EmitArguments.  We do not emit the original
3361         arguments, instead we emit those which have been converted to
3362         unsigned int expressions.
3363
3364         * statement.cs (Block.EmitMeta): Drop tracking of indexes.
3365
3366         * codegen.cs: ditto.
3367
3368         * expression.cs (LocalVariableReference): Drop the use of the
3369         Store function that depended on the variable index.
3370
3371         * statement.cs (VariableInfo): Drop the `Idx' property from this
3372         class, as this is not taking into account the indexes for
3373         temporaries tat we generate during the execution, getting the
3374         indexes wrong.
3375
3376         * class.cs: First emit class initializers, then call the parent
3377         constructor.
3378
3379         * expression.cs (Binary): Fix opcode emision.
3380         (UnaryMutator.EmitCode): Support checked code generation
3381
3382         * ecore.cs (MemberLookup): TypeManager.FindMembers will return
3383         matches for events for both the Static and Instance scans,
3384         pointing to the same element.   Fix that.
3385
3386 2002-03-14  Miguel de Icaza  <miguel@ximian.com>
3387
3388         * rootcontext.cs (ResolveTree): Always set the
3389         interface_resolve_order, because nested interfaces will be calling
3390         into us.
3391
3392         * class.cs (GetInterfaceOrClass): Track the same resolution
3393         process used by TypeManager.LookupType.  This fixes the nested
3394         type lookups in class declarations (separate path from
3395         LookupType).
3396
3397         (TypeContainer.DefineType): Also define nested interfaces.
3398         (TypeContainer.RegisterOrder): New public function used to
3399         register the order in which child interfaces need to be closed.
3400
3401         Nested interfaces need to be closed after their parents have been
3402         created.
3403
3404         * interface.cs (InterfaceAttr): Put all the logic for computing
3405         the interface attribute here.
3406
3407         (DefineInterface): Register our interface order with the
3408         RootContext or with the TypeContainer depending on the case.
3409
3410 2002-03-12  Miguel de Icaza  <miguel@ximian.com>
3411
3412         * cs-parser.jay: rework foreach statement to work with the new
3413         changes to the policy on SimpleNames.
3414
3415         * report.cs: support Stacktrace on warnings as well.
3416
3417         * makefile: drop --unsafe and /unsafe from the compile.
3418
3419 2002-03-13  Ravi Pratap  <ravi@ximian.com>
3420
3421         * ecore.cs (StandardConversionExists): Modify to take an Expression
3422         as the first parameter. Ensure we do null -> reference type conversion
3423         checking.
3424
3425         * Everywhere : update calls accordingly, making use of MyEmptyExpr to store
3426         temporary Expression objects.
3427
3428 Wed Mar 13 12:32:40 CET 2002 Paolo Molaro <lupus@ximian.com>
3429
3430         * interface.cs: workaround bug in method overloading resolution
3431         (there is already a bugzilla bug for it).
3432
3433 2002-03-12  Miguel de Icaza  <miguel@ximian.com>
3434
3435         We could also solve this problem by having a separate path for
3436         performing type lookups, instead of DoResolve, we could have a
3437         ResolveType entry point, and only participating pieces of the
3438         production (simplename, deref, array) would implement this.
3439
3440         * codegen.cs (EmitContext): New field OnlyLookupTypes used to
3441         signal SimpleName to only resolve type names and not attempt to
3442         resolve anything else.
3443
3444         * expression.cs (Cast): Set the flag.
3445
3446         * ecore.cs (SimpleName): Use the OnlyLookupTypes flag
3447
3448         * class.cs: Only report 108 if there is no `new' modifier.
3449
3450         * cs-parser.jay: rework foreach statement to work with the new
3451         changes to the policy on SimpleNames.
3452
3453         * report.cs: support Stacktrace on warnings as well.
3454
3455         * makefile: drop --unsafe and /unsafe from the compile.
3456
3457 2002-03-11  Miguel de Icaza  <miguel@ximian.com>
3458
3459         * ecore.cs (SimpleName.SimpleNameResolve): Perform local variable
3460         lookups here, instead of doing that at parse time.  This means
3461         that our grammar will not introduce `LocalVariableReferences' as
3462         expressions at this point.  That solves the problem of code like
3463         this:
3464
3465         class X {
3466            static void Main ()
3467            { int X = 1;
3468             { X x = null }}}
3469
3470         This is only half the fix.  The full fix requires parameters to
3471         also be handled in this way.
3472
3473         * Everywhere: Use ec.DeclSpace on calls to LookupType, as this
3474         makes the use more obvious of the DeclSpace.  The
3475         ec.TypeContainer.TypeBuilder is now only used to pull the
3476         TypeBuilder for it.
3477
3478         My theory is that I can get rid of the TypeBuilder completely from
3479         the EmitContext, and have typecasts where it is used (from
3480         DeclSpace to where it matters).
3481
3482         The only pending problem is that the code that implements Aliases
3483         is on TypeContainer, and probably should go in DeclSpace.
3484
3485         * ecore.cs (SimpleName.SimpleNameResolve): Perform local variable
3486         lookups here, instead of doing that at parse time.  This means
3487         that our grammar will not introduce `LocalVariableReferences' as
3488         expressions at this point.  That solves the problem of code like
3489         this:
3490
3491         class X {
3492            static void Main ()
3493            { int X = 1;
3494             { X x = null }}}
3495
3496         This is only half the fix.  The full fix requires parameters to
3497         also be handled in this way.
3498
3499         * class.cs (Property.DefineMethod): When implementing an interface
3500         method, set newslot, when implementing an abstract method, do not
3501         set the flag (before we tried never setting it, or always setting
3502         it, which is the difference).
3503         (Indexer.DefineMethod): same.
3504         (Method.DefineMethod): same.
3505
3506         * ecore.cs: Only set the status used flag if we get back a Field.
3507
3508         * attribute.cs: Temporary hack, so Paolo can keep working.
3509
3510 2002-03-08  Ravi Pratap  <ravi@ximian.com>
3511
3512         * attribute.cs (Attribute.UnmanagedType): This is to keep track of
3513         the unmanaged type in the case we have a MarshalAs attribute.
3514
3515         (Resolve): Handle the case when we are parsing the special MarshalAs
3516         attribute [we need to store the unmanaged type to use later]
3517
3518         * typemanager.cs (marshal_as_attr_type): Built in type for the
3519         MarshalAs Attribute.
3520
3521         * attribute.cs (ApplyAttributes): Recognize the MarshalAs attribute
3522         on parameters and accordingly set the marshalling info.
3523
3524 2002-03-09  Miguel de Icaza  <miguel@ximian.com>
3525
3526         * class.cs: Optimizing slightly by removing redundant code after
3527         we switched to the `NoTypes' return value.
3528         (Property.DefineMethod): use NoTypes here too.
3529
3530         This fixes the bug I introduced in my last batch of changes.
3531
3532 2002-03-05  Ravi Pratap  <ravi@ximian.com>
3533
3534         * tree.cs (RecordEnum): Add. We now keep track of enums too.
3535
3536         * class.cs (LookupInterfaceOrClass): Check against the list of recorded
3537         Enums since those are types too.
3538
3539         * cs-parser.jay (enum_declaration): Record enums as we parse them.
3540
3541         * enum.cs (DefineEnum): Return if the TypeBuilder has already been defined
3542         thanks to a call during the lookup process.
3543
3544 2002-03-07  Miguel de Icaza  <miguel@ximian.com>
3545
3546         * statement.cs (Foreach): Lots of work to accomodate a particular
3547         kind of foreach statement that I had not kept in mind.  It is
3548         possible to have foreachs on classes that provide a GetEnumerator
3549         method that return objects that implement the "pattern" for using
3550         a foreach, there is no need to support GetEnumerator
3551         specifically.
3552
3553         This is needed to compile nant.
3554
3555         * decl.cs: Only report 114 if the member is not `Finalize' and if
3556         the warning level is at least 2.
3557
3558         * class.cs: Moved the compare function from Method to
3559         MethodSignature.
3560
3561         (MethodSignature.InheritableMemberSignatureCompare): Add new
3562         filter function that is used to extract inheritable methods from a
3563         class.
3564
3565         (Method.Define): Use the new `inheritable_method_signature_filter'
3566         delegate
3567
3568         * cs-tokenizer.cs (get_cmd_arg): Do not add white space to the
3569         command.
3570
3571 2002-03-06  Miguel de Icaza  <miguel@ximian.com>
3572
3573         * ecore.cs (Expression.ConvertReferenceExplicit): Removed dead code.
3574
3575         * cs-parser.jay: Add opt_semicolon to the interface declaration.
3576
3577         * expression.cs: Pass location information to
3578         ConvertImplicitStandard.
3579
3580         * class.cs: Added debugging code to track return values from
3581         interfaces.
3582
3583 2002-03-05  Miguel de Icaza  <miguel@ximian.com>
3584
3585         * expression.cs (Is.DoResolve): If either side of the `is' is an
3586         interface, do not flag the warning.
3587
3588         * ecore.cs (ImplicitReferenceConversion): We need a separate test
3589         for interfaces
3590
3591         * report.cs: Allow for --fatal to be used with --probe.
3592
3593         * typemanager.cs (NoTypes): Move the definition for the empty Type
3594         array here.
3595
3596         * class.cs (TypeContainer.FindMembers): Also look for methods defined by
3597         properties.
3598         (TypeContainer.DefineProxy): New function used to proxy to parent
3599         implementations when implementing interfaces.
3600         (TypeContainer.ParentImplements): used to lookup if our parent
3601         implements a public function that is required by an interface.
3602         (TypeContainer.VerifyPendingMethods): Hook this up.
3603
3604         * typemanager.cs (TypeManager, AddModule, AddAssembly): Make the
3605         `modules' and `assemblies' arraylists into arrays.  We only grow
3606         these are the very early start up of the program, so this improves
3607         the speedof LookupType (nicely measured).
3608
3609         * expression.cs (MakeByteBlob): Replaced unsafe code with
3610         BitConverter, as suggested by Paolo.
3611
3612         * cfold.cs (ConstantFold.Binary): Special case: perform constant
3613         folding of string concatenation, but if either side is a string,
3614         and the other is not, then return null, and let the runtime use
3615         the concatenation on the string plus the object (using
3616         `Object.ToString').
3617
3618 2002-03-04  Miguel de Icaza  <miguel@ximian.com>
3619
3620         Constant Folding has been implemented now.
3621
3622         * expression.cs (Unary.Reduce): Do not throw an exception, catch
3623         the error instead on types that are not supported in one's
3624         complement.
3625
3626         * constant.cs (Constant and all children): New set of functions to
3627         perform implict and explicit conversions.
3628
3629         * ecore.cs (EnumConstant): Implement the new functions to perform
3630         conversion by proxying to the child expression.
3631
3632         * codegen.cs: (ConstantCheckState): Constant evaluation has its
3633         own separate setting that can not be turned off from the command
3634         line using --unchecked or --checked and is only controlled using
3635         the checked/unchecked statements and expressions.  This setting is
3636         used by the constant folder to flag errors.
3637
3638         * expression.cs (CheckedExpr, UncheckedExpr): Set the
3639         ConstantCheckState as well.
3640
3641         During Resolve, they also have to flag the state, because the
3642         constant folder runs completely in the Resolve phase.
3643
3644         * statement.cs (Checked, Unchecked): Set the ConstantCheckState as
3645         well.
3646
3647 2002-03-01  Miguel de Icaza  <miguel@ximian.com>
3648
3649         * cfold.cs: New file, this file contains the constant folder.
3650
3651         * ecore.cs (IMemoryLocation.AddressOf): Now takes an extra
3652         argument to track whether we are using the resulting address to
3653         load or store a value and provide better error messages.
3654
3655         (FieldExpr.Emit, FieldExpr.EmitAssign, FieldExpr.AddressOf): Use
3656         new AddressOf arguments.
3657
3658         * statement.cs (Foreach.EmitCollectionForeach): Update
3659
3660         * expression.cs (Argument.Emit): Call AddressOf with proper
3661         arguments to track usage.
3662
3663         (New.DoEmit): Call AddressOf with new arguments.
3664
3665         (Unary.Emit): Adjust AddressOf call.
3666
3667 2002-03-01  Ravi Pratap  <ravi@ximian.com>
3668
3669         * cs-parser.jay (member_access): Change the case for pre-defined types
3670         to use a MemberAccess instead of a SimpleName. Thanks to Felix again for
3671         this suggestion.
3672
3673         * class.cs (Operator::Emit): If we are abstract or extern, we don't have
3674         a method body.
3675
3676         * attribute.cs (CheckAttribute, ApplyAttribute): Ensure that we treat operators
3677         essentially like methods and apply attributes like MethodImplOptions to them too.
3678
3679         * ecore.cs (SimpleName.SimpleNameResolve): Perform a check on ec.TypeContainer.TypeBuilder
3680         not being null.
3681
3682         * codegen.cs (EmitContext): The constructor now takes in an extra argument specifying the
3683         DeclSpace as the distinction is important. We provide sane defaults as usually the TypeContainer
3684         is the DeclSpace.
3685
3686         * Update code everywhere accordingly.
3687
3688         * ecore.cs : Change references to ec.TypeContainer to ec.DeclSpace where appropriate.
3689
3690         * cs-parser.jay (enum_declaration): Set the current namespace of the enum.
3691
3692 2002-02-28  Ravi Pratap  <ravi@ximian.com>
3693
3694         * rootcontext.cs (LookupType): As we cycle through the chain of namespaces
3695         try performing lookups against those instead of jumping straight into using
3696         the 'using' clauses.
3697
3698         (ImplicitParent): Add. Thanks to Felix Arrese-Igor for this idea.
3699
3700         (LookupType): Perform lookups in implicit parents too.
3701
3702         * class.cs (GetInterfaceOrClass): Modify to perform the exact same lookup
3703         sequence as RootContext.LookupType.
3704
3705         * rootcontext.cs (NamespaceLookup): Split out code from LookupType which tries
3706         the various cases of namespace lookups into this method.
3707
3708 2002-03-01  Miguel de Icaza  <miguel@ximian.com>
3709
3710         * cs-parser.jay: Add support for [Attribute ()] (empty arguments
3711         in positional arguments)
3712
3713         * class.cs (Operator): Update the AllowedModifiers to contain
3714         extern.
3715
3716         * cs-parser.jay: Update operator declaration to allow for the
3717         operator body to be empty.
3718
3719         * cs-tokenizer.cs: Added '\u' unicode support in strings and hex
3720         values.
3721
3722 2002-02-27  Miguel de Icaza  <miguel@ximian.com>
3723
3724         * class.cs (Method.Emit): Label parameters.
3725
3726         * driver.cs: Return 1 or 0 as the program exit code.
3727
3728 2002-02-26  Miguel de Icaza  <miguel@ximian.com>
3729
3730         * expression.cs: Special case the `null' object when trying to
3731         auto-compute the type, as anything can be explicitly converted to
3732         that.
3733
3734         * ecore.cs (Expression.ConvertExplicit): Bug fix, thanks for
3735         spotting this Paolo.
3736
3737         (Expression.ImplicitNumericConversion): Perform comparissions of
3738         the type using the underlying type in the case of an enumeration
3739         rather than using the enumeration type for the compare.
3740
3741         Cope with the underlying == type case, which is not possible to
3742         catch before.
3743
3744         (Expression.ConvertNumericExplicit): Perform comparissions of
3745         the type using the underlying type in the case of an enumeration
3746         rather than using the enumeration type for the compare.
3747
3748         * driver.cs: If the user does not supply an extension, assume .exe
3749
3750         * cs-parser.jay (if_statement): Rewrote so that we can track the
3751         location for the if statement.
3752
3753         * expression.cs (Binary.ConstantFold): Only concat strings when
3754         the operation is "+", not everything ;-)
3755
3756         * statement.cs (Statement.EmitBoolExpression): Take a location
3757         argument.
3758         (If, While, Do): Track location.
3759
3760         * expression.cs (Binary.ResolveOperator): In the object + string
3761         case, I was missing a call to ConvertImplicit
3762
3763 2002-02-25  Ravi Pratap  <ravi@ximian.com>
3764
3765         * parameter.cs (Parameter.ExternalType): Take in extra DeclSpace and
3766         Location arguments. Ensure we use RootContext.LookupType to do our work
3767         and not try to do a direct Type.GetType and ModuleBuilder.GetType
3768
3769         * interface.cs (PopulateMethod): Handle the type of the parameter being
3770         null gracefully.
3771
3772         * expression.cs (Invocation.BetterFunction): Handle the case when we
3773         have a params method with no fixed arguments and a call is made with no
3774         arguments.
3775
3776 2002-02-25  Miguel de Icaza  <miguel@ximian.com>
3777
3778         * cs-tokenizer.cs: Add support for the quote-escape-sequence in
3779         the verbatim-string-literal
3780
3781         * support.cs (InternalParameters.ParameterModifier): handle null
3782         fixed parameters.
3783         (InternalParameters.ParameterType): ditto.
3784
3785         * parameter.cs (VerifyArgs): Also check if the fixed parameter is
3786         duplicating the name of the variable parameter.
3787         (GetParameterByName): Fix bug where we were not looking up array
3788         paramters if they were the only present (thanks Paolo!).
3789         (GetParameterInfo): We only have an empty set of types if both
3790         fixed and array are set to null.
3791         (GetParameterInfo-idx): Handle FixedParameter == null
3792
3793         * cs-parser.jay: Handle the case where there is no catch
3794         statements (missing null test).
3795
3796 2002-02-22  Miguel de Icaza  <miguel@ximian.com>
3797
3798         * driver.cs (MainDriver): Be conservative on our command line
3799         handling.
3800
3801         Catch DirectoryNotFoundException when calling GetFiles.
3802
3803         (SplitPathAndPattern): Used to split the input specification into
3804         a path and a pattern that we can feed to Directory.GetFiles.
3805
3806 2002-02-21  Miguel de Icaza  <miguel@ximian.com>
3807
3808         * statement.cs (Fixed): Implement the last case of the Fixed
3809         statement (string handling).
3810
3811         * expression.cs (StringPtr): New class used to return a char * to
3812         a string;  Used by the Fixed statement.
3813
3814         * typemanager.cs: Add char_ptr_type.  Add get_OffsetToStringData method.
3815
3816         * expression.cs (Binary.ResolveOperator): Remove redundant
3817         MemberLookup pn parent type.
3818         Optimize union call, we do not need a union if the types are the same.
3819         (Unary.ResolveOperator): REmove redundant MemberLookup on parent
3820         type.
3821
3822         Specialize the use of MemberLookup everywhere, instead of using
3823         the default settings.
3824
3825         (StackAlloc): Implement stackalloc keyword.
3826
3827         * cs-parser.jay: Add rule to parse stackalloc.
3828
3829         * driver.cs: Handle /h, /help, /?
3830
3831         * expression.cs (MakeByteBlob): Removed the hacks we had in place
3832         before we supported unsafe code.
3833
3834         * makefile: add --unsafe to the self compilation of mcs.
3835
3836 2002-02-20  Miguel de Icaza  <miguel@ximian.com>
3837
3838         * expression.cs (PointerArithmetic): New class that is used to
3839         perform pointer arithmetic.
3840         (Binary.Resolve): Handle pointer arithmetic
3841         Handle pointer comparission.
3842         (ArrayPtr): Utility expression class that is used to take the
3843         address of an array.
3844
3845         (ElementAccess): Implement array access for pointers
3846
3847         * statement.cs (Fixed): Implement fixed statement for arrays, we
3848         are missing one more case before we are done.
3849
3850         * expression.cs (Indirection): Implement EmitAssign and set the
3851         ExprClass to Variable.  This allows pointer dereferences to be
3852         treated as variables, and to have values assigned to them.
3853
3854         * ecore.cs (Expression.StoreFromPtr): New utility function to
3855         store values dereferencing.
3856
3857 2002-02-20  Ravi Pratap  <ravi@ximian.com>
3858
3859         * expression.cs (Binary.ResolveOperator): Ensure that we are
3860         not trying to operate on a void type - this fixes the reported
3861         bug.
3862
3863         * decl.cs (CheckMethodAgainstBase): Do not allow overriding if
3864         the parent implementation is sealed.
3865
3866         * ../errors/cs0239.cs : Add.
3867
3868         * attribute.cs (ApplyAttributes): Handle Modulebuilders too.
3869
3870         * typemanager.cs (unverifiable_code_type): Corresponds to
3871         System.Security.UnverifiableCodeAttribute. We need to emit this for modules
3872         which have unsafe code in them.
3873
3874         * rootcontext.cs (EmitCode): Emit the above attribute when we are in an
3875         unsafe context.
3876
3877 2002-02-19  Miguel de Icaza  <miguel@ximian.com>
3878
3879         * cs-tokenizer.cs: Add support for @"litreal strings"
3880
3881         Make tokenizer accept pre-processor directives
3882         on any column (remove the old C-like limitation).
3883
3884         * rootcontext.cs (EmitCode): Emit any global attributes.
3885         (AddGlobalAttributes): Used to keep track of assembly attributes.
3886
3887         * attribute.cs (ApplyAttributes): Support AssemblyAttributes.
3888
3889         * cs-parser.jay: Add support for global attributes.
3890
3891 2002-02-17  Miguel de Icaza  <miguel@ximian.com>
3892
3893         * expression.cs (Indirection): New helper class.  Unary will
3894         create Indirection classes to be able to implement the
3895         IMemoryLocation interface on it.
3896
3897 2002-02-16  Miguel de Icaza  <miguel@ximian.com>
3898
3899         * cs-parser.jay (fixed_statement): reference the right statement.
3900
3901         * statement.cs (Fixed.Emit): Finish implementing the fixed
3902         statement for the &x case.
3903
3904 2002-02-14  Miguel de Icaza  <miguel@ximian.com>
3905
3906         * class.cs (Property.Define, Method.Define): Remove newslot when
3907         `implementing'.
3908
3909         * modifiers.cs: My use of NewSlot when `Abstract' was set was
3910         wrong.  NewSlot should only be used if the `new' keyword is present.
3911
3912         * driver.cs (GetSystemDir): Use CodeBase instead of FullName for
3913         locating our system dir.  Sorry about this.
3914
3915 2002-02-13  Miguel de Icaza  <miguel@ximian.com>
3916
3917         * driver.cs (GetSystemDir): Compute correctly the location of our
3918         system assemblies.  I was using the compiler directory instead of
3919         the library directory.
3920
3921 2002-02-13  Ravi Pratap  <ravi@ximian.com>
3922
3923         * expression.cs (BetterFunction): Put back in what Miguel commented out
3924         since it is the correct fix. The problem is elsewhere ;-)
3925
3926         (IsParamsMethodApplicable): Fix bug where we were not checking that the fixed
3927         parameters of the parms method are themselves compatible or not !
3928
3929         (StandardConversionExists): Fix very dangerous bug where we were forgetting
3930         to check that a class implements an interface before saying that an implicit
3931         conversion was allowed. Use ImplementsInterface to do the checking.
3932
3933 2002-02-13  Miguel de Icaza  <miguel@ximian.com>
3934
3935         * class.cs (Method.Define): Track whether we are an explicit
3936         implementation or not.  And only call DefineMethodOverride if we
3937         are an explicit implementation.
3938
3939         (Property.DefineMethod): Ditto.
3940
3941 2002-02-11  Ravi Pratap  <ravi@ximian.com>
3942
3943         * expression.cs (BetterFunction): Catch hideous bug which was
3944          preventing us from detecting ambiguous calls due to implicit casts i.e
3945         cs0121.
3946
3947 2002-01-29  Miguel de Icaza  <miguel@ximian.com>
3948
3949         * support.cs (Pair): Remove un-needed method.  I figured why I was
3950         getting the error in cs-parser.jay, the variable in a foreach loop
3951         is readonly, and the compiler does not really treat this as a variable.
3952
3953         * cs-parser.jay (fixed_statement): Fix grammar.  Use ASSIGN
3954         instead of EQUALS in grammar.
3955
3956         * typemanager.cs (VerifyUnmanaged): Report correct error (208)
3957
3958         * expression.cs (Unary.DoResolve): Check whether the argument is
3959         managed or not.
3960
3961 2002-01-28  Miguel de Icaza  <miguel@ximian.com>
3962
3963         * support.cs: Api for Pair to set a value.  Despite the fact that
3964         the variables are public the MS C# compiler refuses to compile
3965         code that accesses the field if the variable is part of a foreach
3966         statement.
3967
3968         * statement.cs (Fixed): Begin implementation of the fixed
3969         statement.
3970
3971         (Block.AddVariable): Return the VariableInfo on success and null
3972         on failure instead of true/false.
3973
3974         * cs-parser.jay (foreach): Catch errors on variables already
3975         defined (we were ignoring this value before) and properly unwind
3976         the block hierarchy
3977
3978         (fixed_statement): grammar for the fixed statement.
3979
3980 2002-01-25  Miguel de Icaza  <miguel@ximian.com>
3981
3982         * expression.cs (UnaryMutator.IsIncrementableNumber): Allow also
3983         pointer types to be incretemented.
3984
3985         (SizeOf): Implement.
3986
3987         * cs-parser.jay (pointer_member_access): Implement
3988         expr->IDENTIFIER production.
3989
3990         * expression.cs (IndexerAccess.DoResolve, ArrayAccess.DoResolve,
3991         MemberAccess.DoResolve, Invocation.DoResolve): Check for pointers
3992         on safe contexts.
3993
3994         (Unary): Implement indirection.
3995
3996         * ecore.cs (Expression.UnsafeError): Reports error 214 (pointer
3997         use in non-unsafe context).
3998
3999         (SimpleName.DoResolve): Check for pointers in field access on safe
4000         contexts.
4001
4002         (Expression.LoadFromPtr): Factor the load-indirect code in this
4003         function.  This was duplicated in UnboxCast and ParameterReference
4004
4005 2002-01-24  Miguel de Icaza  <miguel@ximian.com>
4006
4007         * expression.cs (ComposedCast): report an error if a pointer cast
4008         is used in a safe region.
4009
4010         * ecore.cs (Expression.ConvertExplicit): Add rules for implicit
4011         pointer type casts in unsafe context.
4012
4013         * codegen.cs (EmitContext): Set up IsUnsafe.
4014
4015         * cs-parser.jay (non_expression_type): Add productions for pointer
4016         casts.
4017
4018         * expression.cs (Invocation.EmitCall): Remove chunk of buggy
4019         code.  We should not use force into static mode if the method is
4020         not virtual.  Fixes bug in MIS
4021
4022         * statement.cs (Do.Emit, While.Emit, For.Emit,
4023         Statement.EmitBoolExpression): Add support to Do and While to
4024         propagate infinite loop as `I do return' semantics.
4025
4026         Improve the For case to also test for boolean constants.
4027
4028         * attribute.cs (Attribute.ApplyAttributes): Add ParameterBuilder
4029         to the list of attributes we can add.
4030
4031         Remove `EmitContext' argument.
4032
4033         * class.cs (Method.Define): Apply parameter attributes.
4034         (Constructor.Define): Apply parameter attributes.
4035         (MethodCore.LabelParameters): Move here the core of labeling
4036         parameters.
4037
4038         * support.cs (ReflectionParameters.ParameterModifier,
4039         InternalParameters.ParameterModifier): Use IsByRef on the type and
4040         only return the OUT bit for these parameters instead of in/out/ref
4041         flags.
4042
4043         This is because I miss-understood things.  The ParameterInfo.IsIn
4044         and IsOut represent whether the parameter has the [In] and [Out]
4045         attributes set.
4046
4047 2002-01-22  Miguel de Icaza  <miguel@ximian.com>
4048
4049         * ecore.cs (FieldExpr.Emit): Release temporaries.
4050
4051         * assign.cs (LocalTemporary.Release): new function.
4052
4053         * codegen.cs (EmitContext.GetTemporaryStorage,
4054         EmitContext.FreeTemporaryStorage): Rework the way we deal with
4055         temporary storage.  Now we can "put back" localbuilders when we
4056         are done with them
4057
4058 2002-01-21  Miguel de Icaza  <miguel@ximian.com>
4059
4060         * ecore.cs (FieldExpr.Emit): Handle initonly fields specially: we
4061         need to make a copy of the variable to generate verifiable code.
4062
4063 2002-01-19  Miguel de Icaza  <miguel@ximian.com>
4064
4065         * driver.cs: Compute dynamically the system directory.
4066
4067         * ecore.cs (CopyNewMethods): reworked, exposed, made public.
4068         Slower, but more generally useful.  Used by the abstract
4069         registering implementation.
4070
4071         * expression.cs (ResolveMemberAccess): Reorder the way we evaluate
4072         the rules for the special rule on Type/instances.  First check if
4073         we have the same name, and if so, try that special static path
4074         rather than the instance path.
4075
4076 2002-01-18  Miguel de Icaza  <miguel@ximian.com>
4077
4078         * cs-parser.jay: Emit 642 (warning: possible empty statement) for
4079         for, while and if.
4080
4081         * class.cs (TypeBuilder.DefineType): Do not allow inheritance from
4082         Enum, ValueType, Delegate or Array for non-corlib compiles.
4083
4084         * cs-tokenizer.cs: Catch long identifiers (645)
4085
4086         * typemanager.cs (IndexerPropetyName): Ravi never tested this
4087         piece of code.
4088
4089         * class.cs (TypeContainer.RegisterRequiredImplementations): Bug
4090         fix, we were returning too early, so we were not registering
4091         pending methods from abstract classes.
4092
4093         Do not register pending methods if the class is abstract.
4094
4095         * expression.cs (Conditional.DoResolve): Report circular implicit
4096         conversions when we neecd to compute it for conditional
4097         expressions.
4098
4099         (Is.DoResolve): If the expression is always of the provided type,
4100         flag warning 183.  If the expression can not ever be of the
4101         provided type flag warning 184.
4102
4103         * class.cs: Catch 169 as well.
4104
4105         * ecore.cs (FieldExpr): For now in AddressOf mark as assigned and
4106         read.
4107
4108 2002-01-18  Nick Drochak  <ndrochak@gol.com>
4109
4110         * makefile: remove path to beta2 csc.exe.  path to csc.exe must be in PATH instead.
4111
4112 2002-01-17  Miguel de Icaza  <miguel@ximian.com>
4113
4114         * interface.cs: (PopulateMethod): Check for pointers being defined
4115         only if the unsafe context is active.
4116         (PopulateProperty): ditto.
4117         (PopulateIndexer): ditto.
4118
4119         * class.cs (Method, Method.Define): Allow `unsafe' modifier to be
4120         specified.  If pointers are present, make sure that they are
4121         present in an unsafe context.
4122         (Constructor, Constructor.Define): ditto.
4123         (Field, Field.Define): ditto.
4124         (Property, Property.Define): ditto.
4125         (Event, Event.Define): ditto.
4126
4127         * interface.cs (Interface.GetInterfaceTypeByName): Only lookup the
4128         hashtable if there are classes or structs defined.
4129
4130         * expression.cs (LocalVariableReference.DoResolve): Simplify this
4131         code, as the constant resolution moved.
4132
4133         * statement.cs (Block.EmitMeta): Resolve all constants as we emit
4134         the metadata, so we can flag error 133.
4135
4136         * decl.cs (MemberCore.UnsafeOK): New function to test that a
4137         pointer is being declared in an unsafe context.
4138
4139 2002-01-16  Miguel de Icaza  <miguel@ximian.com>
4140
4141         * modifiers.cs (Modifiers.Check): Require a Location argument.
4142         Report error 227 for Unsafe use.
4143
4144         * typemanager.cs: Remove IsPointerType, we should be using Type.IsPointer
4145
4146         * statement.cs (For.Emit): If the test is null, then report that
4147         we do `return', as we wont reach anything afterwards.
4148
4149         (Switch.SwitchGoverningType): Track the expression that matched
4150         the conversion.
4151
4152         * driver.cs: Allow negative numbers as an error code to flag.
4153
4154         * cs-parser.jay: Handle 1551.
4155
4156         * namespace.cs: Add 1537 checking (repeated using alias namespaces).
4157
4158 2002-01-15  Miguel de Icaza  <miguel@ximian.com>
4159
4160         * cs-parser.jay: Report 1518 (type declaration can only contain
4161         class, struct, interface, enum or delegate)
4162
4163         (switch_label): Report 1523 (keywords `case' or `default' must
4164         preced code)
4165
4166         (opt_switch_sections): Report 1522 (empty switch)
4167
4168         * driver.cs: Report 1515 (response file specified multiple times)
4169         Report 1516 (Source file specified multiple times).
4170
4171         * expression.cs (Argument.Resolve): Signal 1510
4172
4173         (BaseAccess.Resolve, BaseIndexer.Resolve): Signal 1511 (base
4174         access not allowed in static code)
4175
4176 2002-01-11  Ravi Pratap  <ravi@ximian.com>
4177
4178         * typemanager.cs (IsPointerType): Utility method which we are going
4179         to need a lot.
4180
4181         * ecore.cs (ImplicitReferenceConversion): A pointer type cannot be cast to
4182         the object type, so we take care of that.
4183
4184         * expression.cs (FullMethodDesc): Also include the return type in descriptions.
4185
4186         * support.cs (ParameterDesc): Fix minor bug which was causing params tags to be
4187         added to non-params parameters :-)
4188
4189         * typemanager.cs (CSharpName): Include 'void' type too.
4190
4191         (void_ptr_type): Include in the set of core types.
4192
4193         * ecore.cs (ConvertImplicit): Make use of ConvertImplicitStandard instead of
4194         duplicating code.
4195
4196         (ConvertImplicitStandard): Handle standard implicit pointer conversions when we have
4197         an unsafe context.
4198
4199         * cs-parser.jay (local_variable_pointer_type): Add support for 'void *' as I had
4200         completely forgotten about it.
4201
4202 2002-01-10  Ravi Pratap  <ravi@ximian.com>
4203
4204         * cs-parser.jay (pointer_type): Add. This begins our implementation
4205         of parsing rules for unsafe code.
4206
4207         (unsafe_statement): Implement.
4208
4209         (embedded_statement): Modify to include the above.
4210
4211         * statement.cs (Unsafe): Implement new class for unsafe blocks.
4212
4213         * codegen.cs (EmitContext.InUnsafe): Add. This determines
4214         if the current context is an unsafe one.
4215
4216         * cs-parser.jay (local_variable_pointer_type): Since local variable types
4217         are handled differently, we need separate rules for them.
4218
4219         (local_variable_declaration): Update to use local_variable_pointer_type
4220         to allow variable declarations of unmanaged pointer types.
4221
4222         * expression.cs (Unary.ResolveOperator): Ensure that the '&' operator is used only
4223         in unsafe contexts.
4224
4225         * ../errors/cs0214.cs : Add.
4226
4227 2002-01-16  Nick Drochak  <ndrochak@gol.com>
4228
4229         * makefile: remove 'response' file when cleaning.
4230
4231 2002-01-15  Miguel de Icaza  <miguel@ximian.com>
4232
4233         * cs-parser.jay: Report 1524.
4234
4235 2002-01-14  Miguel de Icaza  <miguel@ximian.com>
4236
4237         * typemanager.cs (RegisterMethod): drop checking if we have
4238         registered this from here
4239
4240 2002-01-12  Miguel de Icaza  <miguel@ximian.com>
4241
4242         * class.cs (Method.EmitDestructor): Implement calling our base
4243         destructor.
4244
4245         * statement.cs (Try.Emit): Fix to reset the InFinally to the old
4246         value of InFinally.
4247
4248         * codegen.cs (EmitContext.EmitTopBlock): Destructors will call
4249         this routine and will wrap the call in a try/catch block.  Deal
4250         with the case.
4251
4252 2002-01-11  Miguel de Icaza  <miguel@ximian.com>
4253
4254         * ecore.cs (Expression.MemberLookup): instead of taking a
4255         parameter `same_type' that was used to tell whether we could
4256         access private members we compute our containing type from the
4257         EmitContext.
4258
4259         (FieldExpr): Added partial support for volatile fields.  This does
4260         not work for volatile fields exposed from assemblies, as I can not
4261         figure out how to extract the modreq from it.
4262
4263         Updated all the source files to use this.
4264
4265         * codegen.cs (EmitContext): Compute ContainerType ahead of time,
4266         because it is referenced by MemberLookup very often.
4267
4268 2002-01-09  Ravi Pratap  <ravi@ximian.com>
4269
4270         * typemanager.cs (IndexerPropertyName): If we have a TypeBuilder, use
4271         TypeBuilder.GetCustomAttributes to retrieve what we need.
4272
4273         Get rid of redundant default_member_attr_type as this is the same as
4274         default_member_type which already exists.
4275
4276         * interface.cs, attribute.cs : Update accordingly.
4277
4278 2002-01-08  Miguel de Icaza  <miguel@ximian.com>
4279
4280         * typemanager.cs: Enable IndexerPropertyName again.  It does not
4281         work for TYpeBuilders though.  Ravi, can you please fix this?
4282
4283         * cs-tokenizer.cs: Accept _ as a name in pp-expressions.
4284
4285         * expression.cs (Argument.Emit): Handle the case of ref objects
4286         being passed to ref functions;
4287
4288         (ParameterReference.EmitLoad): Loads the content of the pointer
4289         without dereferencing.
4290
4291 2002-01-07  Miguel de Icaza  <miguel@ximian.com>
4292
4293         * cs-tokenizer.cs: Implemented the pre-processing expressions.
4294
4295 2002-01-08  Ravi Pratap  <ravi@ximian.com>
4296
4297         * class.cs (Indexer.DefineMethod): Incorporate the interface
4298         type in the name of the method if we are doing explicit interface
4299         implementation.
4300
4301         * expression.cs (ConversionExists): Remove as it is completely obsolete.
4302
4303         (BetterConversion): Fix extremely trivial bug where we were referring to
4304         ConversionExists instead of StandardConversionExists ! Hooray, things are fine
4305         again !
4306
4307         * ../errors/bug16.cs : Add although we have fixed it.
4308
4309 2002-01-07  Miguel de Icaza  <miguel@ximian.com>
4310
4311         * expression.cs (BaseIndexer): Begin implementation.
4312
4313         * class.cs (TypeContainer.IsInterfaceMethod): Bug fix.
4314
4315         * cs-parser.jay (indexer_declarator): Use qualified_identifier
4316         production directly to remove a shift/reduce, and implement
4317         explicit interface implementation.
4318
4319         * cs-tokenizer.cs: Fix tokenizer, it was consuming one extra char
4320         after a floating point suffix.
4321
4322         * expression.cs (DoNumericPromotions): Improved the conversion for
4323         uint/uint.  If we have a constant, we avoid doing a typecast to a
4324         larger type.
4325
4326         * class.cs (Indexer): Implement explicit interface implementation
4327         for indexers.
4328
4329 Sat Jan 5 16:08:23 CET 2002 Paolo Molaro <lupus@ximian.com>
4330
4331         * class.cs: make the default instance constructor public and hidebysig.
4332
4333 2001-01-03  Ravi Pratap  <ravi@ximian.com>
4334
4335         * interface.cs (EmitDefaultMemberAttr): Make this helper method static
4336         so we can call it from elsewhere.
4337
4338         * class.cs (TypeContainer.Emit): Emit the attribute here too. The rule is that
4339         we emit it internally if the class has a defined indexer; otherwise the user
4340         emits it by decorating the class definition with the DefaultMemberAttribute.
4341
4342         * attribute.cs (ApplyAttributes): Perform checks to see that the DefaultMember
4343         attribute is not used on a type which defines an indexer.
4344
4345         * cs-tokenizer.cs (get_cmd_arg): Ensure we trim whitespace and also include the tab
4346         character when we skip whitespace.
4347
4348         * ../errors/cs0646.cs : Add.
4349
4350 2002-01-03  Miguel de Icaza  <miguel@ximian.com>
4351
4352         * ecore.cs (SimpleName.ResolveSimpleName): Report error 120
4353         again.
4354
4355         * makefile: Add practical target `mcs3.exe' which builds the third
4356         generation compiler.
4357
4358         * expression.cs (New): Fix structures constructor calling.
4359
4360         * class.cs (Property, Method, Indexer): Emit Final flag on the
4361         method if we are an interface implementation and we are not
4362         abstract.
4363
4364         * ecore.cs (PropertyExpr): New public field `IsBase', tells
4365         whether this property is referencing a `base' method.
4366
4367         * expression.cs (Invocation.EmitCall): take an extra argument:
4368         is_base, this is used to determine whether the `call' or
4369         `callvirt' opcode should be used.
4370
4371
4372         * delegate.cs: update EmitCall.
4373
4374         * class.cs (Method.Define): Set NewSlot for the cases where we are
4375         not implementing an interface method.
4376
4377         (Property.Define): ditto.
4378
4379 2002-01-02  Miguel de Icaza  <miguel@ximian.com>
4380
4381         * cs-tokenizer.cs: (Tokenizer.escape): Escape '\r' as '\r' not as
4382         'r'.  Allows mcs to parse itself fully.
4383
4384 2002-01-02  Ravi Pratap  <ravi@ximian.com>
4385
4386         * expression.cs (ArrayCreation.num_automatic_initializers): Keep track
4387         of the number of initializers that require the InitializeArray method.
4388
4389         (CheckIndices): Store the Expression in all cases - not the plain value. Also
4390         update the above field where necessary.
4391
4392         (MakeByteBlob): Update accordingly.
4393
4394         (DoEmit): Call EmitStaticInitializers only if the number of initializers is
4395         greater than 2.
4396
4397         (EmitDynamicInitializers): Update in accordance with the new optimization.
4398
4399         (ArrayAccess.EmitStoreOpcode): Include char type along with short and ushort - the
4400         same OpCode applies.
4401
4402         * cs-parser.jay : Fix some glaring errors I introduced.
4403
4404 2002-01-01  Ravi Pratap  <ravi@ximian.com>
4405
4406         * parameters.cs (AddVariable, AddConstant): Pass in current_local_parameters
4407         so that we can check for name clashes there too.
4408
4409         * typemanager.cs (default_member_attr_type): The attribute that we need to emit
4410         for interface indexers.
4411
4412         * interfaces.cs (Define): Emit the default member attribute.
4413
4414         * expression.cs (MakeByteBlob): Fix extremely trivial bug where the wrong
4415         variable was being referred to while setting the value ;-)
4416
4417 2002-01-01  Miguel de Icaza  <miguel@ximian.com>
4418
4419         * expression.cs (MakeByteBlob): Optimize: we do not need to fill
4420         byte-by-byte information when we know the data is zero.
4421
4422         Make the block always a multiple of 4, because
4423         DefineInitializedData has a bug.
4424
4425         * assign.cs: Fix, we should assign from the temporary, not from
4426         the source.
4427
4428         * expression.cs (MakeByteBlob): Fix my incorrect code.
4429
4430 2001-12-31  Miguel de Icaza  <miguel@ximian.com>
4431
4432         * typemanager.cs (EnumToUnderlying): This function is used to get
4433         the underlying type from an enumeration, because it does not
4434         always work.
4435
4436         * constant.cs: Use the I4_S form for values between -128 and 127.
4437
4438         * statement.cs (Block.LookupLabel): Looks up a label.
4439         (Block): Drop support for labeled blocks.
4440
4441         (LabeledStatement): New kind of statement that represents a label
4442         only.
4443
4444         (Goto): Finally implement this bad boy.
4445
4446         * cs-parser.jay: Update to reflect new mechanism to implement
4447         labels.
4448
4449 2001-12-30  Miguel de Icaza  <miguel@ximian.com>
4450
4451         * codegen.cs (EmitContext.This): a codegen property that keeps the
4452         a single instance of this instead of creating many different this
4453         instances.
4454
4455         * delegate.cs (Delegate.DoResolve): Update to use the property;
4456
4457         * ecore.cs (SimpleName.SimpleNameResolve): Ditto
4458
4459         * expression.cs (BaseAccess.DoResolve): Ditto.
4460
4461 2001-12-29  Ravi Pratap  <ravi@ximian.com>
4462
4463         * typemanager.cs (methodimpl_attr_type): Add to hold the type
4464         corresponding to System.Runtime.CompilerServices.MethodImplAttribute.
4465
4466         (InitCoreTypes): Update accordingly.
4467
4468         * attribute.cs (Resolve): Remember if the attribute is a MethodImplAttribute
4469         so we can quickly store the state.
4470
4471         (ApplyAttributes): Set the correct implementation flags
4472         for InternalCall methods.
4473
4474 2001-12-29  Miguel de Icaza  <miguel@ximian.com>
4475
4476         * expression.cs (EmitCall): if a method is not virtual, then do
4477         not use callvirt on it.
4478
4479         (ArrayAccess.EmitAssign): storing non-builtin value types (ie,
4480         user defined stuff) requires the use of stobj, which takes an
4481         address on the stack instead of an array and an index.  So emit
4482         the Ldelema operation for it.
4483
4484         (EmitStoreOpcode): Use stobj for valuetypes.
4485
4486         (UnaryMutator.EmitCode): Use the right 1 value depending on
4487         whether we are dealing with int64/uint64, float or doubles.
4488
4489         * class.cs (TypeContainer.AddConstructor): Fix the logic to define
4490         constructors that I implemented last night.
4491
4492         (Constructor.IsDefault): Fix to work properly for static
4493         constructors.
4494
4495         * cs-parser.jay (CheckDef): report method signature errors.
4496         Update error number 103 to be 132.
4497
4498         * decl.cs: New AdditionResult enumeration value: MethodExists.
4499         Although we do this check for methods later on in the semantic
4500         analysis, catching repeated default constructors is so easy that
4501         we catch these here.
4502
4503         * expression.cs (Binary.DoNumericPromotions): Fix the uint64 type
4504         promotions code.
4505
4506         (ParameterReference.EmitAssign, Emit): handle
4507         bools as bytes.
4508
4509         (ArrayAccess.EmitLoadOpcode): Handle bool type here.
4510         (ArrayAccess.EmitStoreOpcode): ditto.
4511
4512         * cs-tokenizer.cs (is_punct): Eliminated empty computation.
4513
4514         * expression.cs (MakeByteBlob): Complete all the missing types
4515         (uint, short, ushort, byte, sbyte)
4516
4517         * class.cs: Only init instance field initializers on instance
4518         constructors.
4519
4520         Rename `constructors' to instance_constructors.
4521
4522         (TypeContainer.AddConstructor): Only add constructors to the list
4523         if it is not static.
4524
4525         Make sure that we handle default_static_constructor independently
4526         everywhere where we handle instance_constructors
4527
4528 2001-12-28  Miguel de Icaza  <miguel@ximian.com>
4529
4530         * class.cs: Do not lookup or create a base initializer for a
4531         static constructor.
4532
4533         (ConstructorInitializer.Resolve): use the proper type to lookup
4534         for constructors.
4535
4536         * cs-parser.jay: Report error 1585 (modifiers between type and name).
4537
4538         * enum.cs, interface.cs: Remove CloseType, this is taken care by
4539         in DeclSpace.
4540
4541         * decl.cs: CloseType is now an virtual method, the default
4542         implementation just closes this type.
4543
4544 2001-12-28  Ravi Pratap  <ravi@ximian.com>
4545
4546         * attribute.cs (DefinePInvokeMethod): Set the implementation flags
4547         to PreserveSig by default. Also emit HideBySig on such methods.
4548
4549         Basically, set the defaults to standard values.
4550
4551         * expression.cs (Invocation.BetterFunction): We need to make sure that for each
4552         argument, if candidate is better, it can't be worse than the best !
4553
4554         (Invocation): Re-write bits to differentiate between methods being
4555         applicable in their expanded form and their normal form - for params
4556         methods of course.
4557
4558         Get rid of use_standard everywhere as only standard conversions are allowed
4559         in overload resolution.
4560
4561         More spec conformance.
4562
4563 2001-12-27  Miguel de Icaza  <miguel@ximian.com>
4564
4565         * driver.cs: Add --timestamp, to see where the compiler spends
4566         most of its time.
4567
4568         * ecore.cs (SimpleName.DoResolve): Do not create an implicit
4569         `this' in static code.
4570
4571         (SimpleName.DoResolve): Implement in terms of a helper function
4572         that allows static-references to be passed upstream to
4573         MemberAccess.
4574
4575         (Expression.ResolveWithSimpleName): Resolve specially simple
4576         names when called by MemberAccess to implement the special
4577         semantics.
4578
4579         (Expression.ImplicitReferenceConversion): Handle conversions from
4580         Null to reference types before others, as Null's type is
4581         System.Object.
4582
4583         * expression.cs (Invocation.EmitCall): Handle the special case of
4584         calling methods declared on a reference type from a ValueType
4585         (Base classes System.Object and System.Enum)
4586
4587         (MemberAccess.Resolve): Only perform lookups on Enumerations if
4588         the left hand side is a TypeExpr, not on every enumeration.
4589
4590         (Binary.Resolve): If types are reference types, then do a cast to
4591         object on operators != and == of both arguments.
4592
4593         * typemanager.cs (FindMembers): Extract instance and static
4594         members if requested.
4595
4596         * interface.cs (PopulateProperty): Use void_type instead of null
4597         as the return type for the setter method.
4598
4599         (PopulateIndexer): ditto.
4600
4601 2001-12-27  Ravi Pratap  <ravi@ximian.com>
4602
4603         * support.cs (ReflectionParameters): Fix minor bug where we
4604         were examining the wrong parameter for the ParamArray attribute.
4605
4606         Cope with requests for the type of the parameter at position
4607         greater than the params parameter's. We now return the element
4608         type of the params array as that makes more sense.
4609
4610         * expression.cs (Invocation.IsParamsMethodApplicable): Update
4611         accordingly as we no longer have to extract the element type
4612         ourselves.
4613
4614         (Invocation.OverloadResolve): Update.
4615
4616 2001-12-27  Miguel de Icaza  <miguel@ximian.com>
4617
4618         * statement.cs (Foreach.GetEnumeratorFilter): Do not compare
4619         against IEnumerator, test whether the return value is a descendant
4620         of the IEnumerator interface.
4621
4622         * class.cs (Indexer.Define): Use an auxiliary method to implement
4623         the other bits of the method definition.  Begin support for
4624         explicit interface implementation.
4625
4626         (Property.DefineMethod): Use TypeManager.void_type instead of null
4627         for an empty return value.
4628
4629 2001-12-26  Miguel de Icaza  <miguel@ximian.com>
4630
4631         * expression.cs (MemberAccess.ResolveMemberAccess): if we are
4632         dealing with a FieldExpr which is composed of a FieldBuilder, in
4633         the code path we did extract the constant, but we should have
4634         obtained the underlying value to be able to cast it (otherwise we
4635         end up in an infinite loop, this is what Ravi was running into).
4636
4637         (ArrayCreation.UpdateIndices): Arrays might be empty.
4638
4639         (MemberAccess.ResolveMemberAccess): Add support for section
4640         14.5.4.1 that deals with the special case of E.I when E is a type
4641         and something else, that I can be a reference to a static member.
4642
4643         (ArrayCreation.MakeByteBlob): It is not an error to not be able to
4644         handle a particular array type to create byte blobs, it is just
4645         something we dont generate byteblobs for.
4646
4647         * cs-tokenizer.cs (get_cmd_arg): Ignore \r in commands and
4648         arguments.
4649
4650         * location.cs (Push): remove the key from the hashtable that we
4651         are about to add.   This happens for empty files.
4652
4653         * driver.cs: Dispose files after we have parsed them.
4654
4655         (tokenize): new function that only runs the tokenizer on its
4656         input, for speed testing.
4657
4658 2001-12-26  Ravi Pratap  <ravi@ximian.com>
4659
4660         * class.cs (Event.Define): Define the private field only if there
4661         are no accessors defined.
4662
4663         * expression.cs (ResolveMemberAccess): If there is no associated
4664         field with the event, that means we have an event defined with its
4665         own accessors and we should flag error cs0070 since transforming
4666         ourselves into a field is not valid in that case.
4667
4668         * ecore.cs (SimpleName.DoResolve): Same as above.
4669
4670         * attribute.cs (DefinePInvokeMethod): Set the default calling convention
4671         and charset to sane values.
4672
4673 2001-12-25  Ravi Pratap  <ravi@ximian.com>
4674
4675         * assign.cs (DoResolve): Perform check on events only if they
4676         are being accessed outside the declaring type.
4677
4678         * cs-parser.jay (event_declarations): Update rules to correctly
4679         set the type of the implicit parameter etc.
4680
4681         (add_accessor, remove_accessor): Set current local parameters.
4682
4683         * expression.cs (Binary): For delegate addition and subtraction,
4684         cast the return value from the method into the appropriate delegate
4685         type.
4686
4687 2001-12-24  Ravi Pratap  <ravi@ximian.com>
4688
4689         * typemanager.cs (RegisterDelegateData, GetDelegateData): Get rid
4690         of these as the workaround is unnecessary.
4691
4692         * delegate.cs (NewDelegate.DoResolve): Get rid of bits which registered
4693         delegate data - none of that is needed at all.
4694
4695         Re-write bits to extract the instance expression and the delegate method
4696         correctly.
4697
4698         * expression.cs (Binary.ResolveOperator): Handle the '-' binary operator
4699         on delegates too.
4700
4701         * attribute.cs (ApplyAttributes): New method to take care of common tasks
4702         of attaching attributes instead of duplicating code everywhere.
4703
4704         * everywhere : Update code to do attribute emission using the above method.
4705
4706 2001-12-23  Miguel de Icaza  <miguel@ximian.com>
4707
4708         * expression.cs (IsParamsMethodApplicable): if there are not
4709         parameters, return immediately.
4710
4711         * ecore.cs: The 0 literal can be implicity converted to an enum
4712         type.
4713
4714         (SimpleName.DoResolve): First lookup the type, then lookup the
4715         members.
4716
4717         (FieldExpr.Emit): If the InstanceExpression is a ValueType, we
4718         want to get its address.  If the InstanceExpression is not
4719         addressable, store the result in a temporary variable, then get
4720         the address of it.
4721
4722         * codegen.cs: Only display 219 errors on warning level or above.
4723
4724         * expression.cs (ArrayAccess): Make it implement the
4725         IMemoryLocation interface.
4726
4727         (Binary.DoResolve): handle the operator == (object a, object b)
4728         and operator != (object a, object b) without incurring into a
4729         BoxedCast (because 5 != o should never be performed).
4730
4731         Handle binary enumerator operators.
4732
4733         (EmitLoadOpcode): Use Ldelema if the object we are loading is a
4734         value type, otherwise use Ldelem_ref.
4735
4736         Use precomputed names;
4737
4738         (AddressOf): Implement address of
4739
4740         * cs-parser.jay (labeled_statement): Fix recursive block
4741         addition by reworking the production.
4742
4743         * expression.cs (New.DoEmit): New has a special case:
4744
4745                  If we are dealing with a ValueType, we have a few
4746                  situations to deal with:
4747
4748                     * The target of New is a ValueType variable, that is
4749                       easy, we just pass this as the variable reference
4750
4751                     * The target of New is being passed as an argument,
4752                       to a boxing operation or a function that takes a
4753                       ValueType.
4754
4755                       In this case, we need to create a temporary variable
4756                       that is the argument of New.
4757
4758
4759 2001-12-23  Ravi Pratap  <ravi@ximian.com>
4760
4761         * rootcontext.cs (LookupType): Check that current_type is not null before
4762         going about looking at nested types.
4763
4764         * ecore.cs (EventExpr.EmitAddOrRemove): Rename from EmitAssign as we do
4765         not implement the IAssignMethod interface any more.
4766
4767         * expression.cs (MemberAccess.ResolveMemberAccess): Handle EventExprs specially
4768         where we tranform them into FieldExprs if they are being resolved from within
4769         the declaring type.
4770
4771         * ecore.cs (SimpleName.DoResolve): Do the same here.
4772
4773         * assign.cs (DoResolve, Emit): Clean up code considerably.
4774
4775         * ../errors/bug10.cs : Add.
4776
4777         * ../errors/cs0070.cs : Add.
4778
4779         * typemanager.cs : Use PtrHashtable for Delegate data hashtable etc.
4780
4781         * assign.cs : Get rid of EventIsLocal everywhere.
4782
4783 2001-12-23  Miguel de Icaza  <miguel@ximian.com>
4784
4785         * ecore.cs (ConvertIntLiteral): finished the implementation.
4786
4787         * statement.cs (SwitchLabel): Convert the value we are using as a
4788         key before looking up the table.
4789
4790 2001-12-22  Miguel de Icaza  <miguel@ximian.com>
4791
4792         * codegen.cs (EmitTopBlock): Require a Location argument now.
4793
4794         * cs-parser.jay (constructor_declarator): We need to setup
4795         current_local_parameters before we parse the
4796         opt_constructor_initializer, to allow the variables to be bound
4797         to the constructor arguments.
4798
4799         * rootcontext.cs (LookupType): First lookup nested classes in our
4800         class and our parents before we go looking outside our class.
4801
4802         * expression.cs (ConstantFold): Extract/debox the values at the
4803         beginnning.
4804
4805         * rootcontext.cs (EmitCode): Resolve the constants first before we
4806         resolve the types.  This is not really needed, but it helps debugging.
4807
4808         * statement.cs: report location.
4809
4810         * cs-parser.jay: pass location to throw statement.
4811
4812         * driver.cs: Small bug fix.
4813
4814         * report.cs: Updated format to be 4-zero filled digits.
4815
4816 2001-12-22  Ravi Pratap  <ravi@ximian.com>
4817
4818         * expression.cs (CheckIndices): Fix minor bug where the wrong
4819         variable was being referred to ;-)
4820
4821         (DoEmit): Do not call EmitStaticInitializers when the
4822         underlying type is System.Object.
4823
4824 2001-12-21  Ravi Pratap  <ravi@ximian.com>
4825
4826         * ecore.cs (EventExpr.Resolve): Implement to correctly set the type
4827         and do the usual workaround for SRE.
4828
4829         * class.cs (MyEventBuilder.EventType): New member to get at the type
4830         of the event, quickly.
4831
4832         * expression.cs (Binary.ResolveOperator): Handle delegate addition.
4833
4834         * assign.cs (Assign.DoResolve): Handle the case when the target
4835         is an EventExpr and perform the necessary checks.
4836
4837         * ecore.cs (EventExpr.EmitAssign): Implement the IAssignMethod
4838         interface.
4839
4840         (SimpleName.MemberStaticCheck): Include check for EventExpr.
4841
4842         (EventExpr): Set the type in the constructor itself since we
4843         are meant to be born fully resolved.
4844
4845         (EventExpr.Define): Revert code I wrote earlier.
4846
4847         * delegate.cs (NewDelegate.Resolve): Handle the case when the MethodGroup's
4848         instance expression is null. The instance expression is a This in that case
4849         or a null, depending on whether it is a static method or not.
4850
4851         Also flag an error if the reference to a method is ambiguous i.e the MethodGroupExpr
4852         refers to more than one method.
4853
4854         * assign.cs (DoResolve): Check whether the event belongs to the same Type container
4855         and accordingly flag errors.
4856
4857 2001-12-21  Miguel de Icaza  <miguel@ximian.com>
4858
4859         * statement.cs (Throw.Emit): Add support for re-throwing exceptions.
4860
4861 2001-12-22  Miguel de Icaza  <miguel@ximian.com>
4862
4863         * location.cs (ToString): Provide useful rutine.
4864
4865 2001-12-21  Miguel de Icaza  <miguel@ximian.com>
4866
4867         * ecore.cs (Expression.ConvertIntLiteral): Do not return Constant
4868         objects, return the actual integral boxed.
4869
4870         * statement.cs (SwitchLabel): define an ILLabel for each
4871         SwitchLabel.
4872
4873         (Switch.CheckSwitch): If the value is a Literal, extract
4874         the underlying literal.
4875
4876         Also in the unused hashtable we had, add the SwitchLabel so we can
4877         quickly look this value up.
4878
4879         * constant.cs: Implement a bunch of new constants.  Rewrite
4880         Literal based on this.  Made changes everywhere to adapt to this.
4881
4882         * expression.cs (Expression.MakeByteBlob): Optimize routine by
4883         dereferencing array only once, and also copes with enumrations.
4884
4885         bytes are two bytes wide, not one.
4886
4887         (Cast): Perform constant conversions.
4888
4889         * ecore.cs (TryImplicitIntConversion): Return literals instead of
4890         wrappers to the literals here.
4891
4892         * expression.cs (DoNumericPromotions): long literals can converted
4893         to ulong implicity (this is taken care of elsewhere, but I was
4894         missing this spot).
4895
4896         * ecore.cs (Expression.Literalize): Make the return type Literal,
4897         to improve type checking.
4898
4899         * rootcontext.cs: Lookup for nested classes in our class hierarchy.
4900
4901 2001-12-20  Miguel de Icaza  <miguel@ximian.com>
4902
4903         * literal.cs: Revert code from ravi that checked the bounds.  The
4904         bounds are sane by the definition of the type itself.
4905
4906         * typemanager.cs: Fix implementation of ImplementsInterface.  We
4907         need to actually look up in our parent hierarchy for interfaces
4908         implemented.
4909
4910         * const.cs: Use the underlying type for enumerations
4911
4912         * delegate.cs: Compute the basename for the delegate creation,
4913         that should fix the delegate test case, and restore the correct
4914         Type Lookup semantics in rootcontext
4915
4916         * rootcontext.cs: Revert Ravi's last patch.  The correct way of
4917         referencing a nested type with the Reflection API is using the "+"
4918         sign.
4919
4920         * cs-parser.jay: Do not require EOF token at the end.
4921
4922 2001-12-20  Ravi Pratap  <ravi@ximian.com>
4923
4924         * rootcontext.cs (LookupType): Concatenate type names with
4925         a '.' instead of a '+' The test suite passes again.
4926
4927         * enum.cs (Enum.DefineEnum): Set RTSpecialName on the 'value__'
4928         field of the enumeration.
4929
4930         * expression.cs (MemberAccess.ResolveMemberAccess): Add support for
4931         the case when the member is an EventExpr.
4932
4933         * ecore.cs (EventExpr.InstanceExpression): Every event which is not
4934         static has an associated instance expression.
4935
4936         * typemanager.cs (RegisterEvent): The usual workaround, now for events.
4937
4938         (GetAddMethod, GetRemoveMethod): Workarounds, as usual.
4939
4940         * class.cs (Event.Define): Register event and perform appropriate checks
4941         for error #111.
4942
4943         We define the Add and Remove methods even if the use provides none because
4944         in that case, we provide default implementations ourselves.
4945
4946         Define a private field of the type of the event. This is done by the CSC compiler
4947         and we should be doing it too ;-)
4948
4949         * typemanager.cs (delegate_combine_delegate_delegate, delegate_remove_delegate_delegate):
4950         More methods we use in code we generate.
4951
4952         (multicast_delegate_type, delegate_type): Two separate types since the distinction
4953         is important.
4954
4955         (InitCoreTypes): Update accordingly for the above.
4956
4957         * class.cs (Event.Emit): Generate code for default accessors that we provide
4958
4959         (EmitDefaultMethod): Do the job in the above.
4960
4961         * delegate.cs (DefineDelegate): Use TypeManager.multicast_delegate_type in the
4962         appropriate place.
4963
4964 2001-12-20  Miguel de Icaza  <miguel@ximian.com>
4965
4966         * class.cs (Indexer.Define): Fix bug, we were setting both Get/Set
4967         builders even if we were missing one.
4968
4969         * interface.cs, class.cs, enum.cs: When calling DefineNestedType
4970         pass the Basename as our class name instead of the Name.  The
4971         basename will be correctly composed for us.
4972
4973         * parameter.cs (Paramters): Now takes a Location argument.
4974
4975         * decl.cs (DeclSpace.LookupType): Removed convenience function and
4976         make all the code call directly LookupType in RootContext and take
4977         this chance to pass the Location information everywhere.
4978
4979         * Everywhere: pass Location information.
4980
4981 2001-12-19  Miguel de Icaza  <miguel@ximian.com>
4982
4983         * class.cs (Constructor.Define): Updated way of detecting the
4984         length of the parameters.
4985
4986         (TypeContainer.DefineType): Use basename as the type name for
4987         nested types.
4988
4989         (TypeContainer.Define): Do not recursively define types here, as
4990         definition is taken care in order by the RootContext.
4991
4992         * tree.cs: Keep track of namespaces in a per-file basis.
4993
4994         * parameter.cs (Parameter.ComputeSignature): Update to use
4995         DeclSpace.
4996
4997         (Parameters.GetSignature): ditto.
4998
4999         * interface.cs (InterfaceMethod.GetSignature): Take a DeclSpace
5000         instead of a TypeContainer.
5001
5002         (Interface.SemanticAnalysis): Use `this' instead of our parent to
5003         resolve names.  Because we need to be resolve in our context, not
5004         our parents.
5005
5006         * driver.cs: Implement response files.
5007
5008         * class.cs (TypeContainer.DefineType): If we are defined, do not
5009         redefine ourselves.
5010
5011         (Event.Emit): Emit the code for add/remove handlers.
5012         (Event.Define): Save the MethodBuilders for add/remove.
5013
5014         * typemanager.cs: Use pair here too.
5015
5016         * cs-parser.jay: Replaced use of DictionaryEntry for Pair because
5017         DictionaryEntry requires the first argument to be non-null.
5018
5019         (enum_declaration): Compute full name for registering the
5020         enumeration.
5021
5022         (delegate_declaration): Instead of using
5023         formal_parameter_list, use opt_formal_parameter_list as the list
5024         can be empty.
5025
5026         * cs-tokenizer.cs (PropertyParsing): renamed from `properties'
5027         (EventParsing): New property that controls whether `add' and
5028         `remove' are returned as tokens or identifiers (for events);
5029
5030 2001-12-19  Ravi Pratap  <ravi@ximian.com>
5031
5032         * class.cs (Event.Define): Revamp use of EventBuilder completely. We now
5033         use MyEventBuilder only and let it wrap the real builder for us.
5034
5035         (MyEventBuilder): Revamp constructor etc.
5036
5037         Implement all operations that we perform on EventBuilder in precisely the same
5038         way here too.
5039
5040         (FindMembers): Update to use the EventBuilder member.
5041
5042         (Event.Emit): Update accordingly.
5043
5044 2001-12-18  Ravi Pratap  <ravi@ximian.com>
5045
5046         * class.cs (MyEventBuilder.Set*): Chain to the underlying builder
5047         by calling the appropriate methods.
5048
5049         (GetCustomAttributes): Make stubs as they cannot possibly do anything
5050         useful.
5051
5052         (Event.Emit): Use MyEventBuilder everywhere - even to set attributes.
5053
5054 2001-12-17  Ravi Pratap  <ravi@ximian.com>
5055
5056         * delegate.cs (Delegate.Populate): Check that the return type
5057         and various parameters types are indeed accessible.
5058
5059         * class.cs (Constructor.Define): Same here.
5060
5061         (Field.Define): Ditto.
5062
5063         (Event.Define): Ditto.
5064
5065         (Operator.Define): Check that the underlying Method defined itself
5066         correctly - so it's MethodBuilder should not be null.
5067
5068         * delegate.cs (DelegateInvocation.DoResolve): Bale out if the type of the Instance
5069         expression happens to be null.
5070
5071         * class.cs (MyEventBuilder): Workaround for SRE lameness. Implement various abstract
5072         members but as of now we don't seem to be able to do anything really useful with it.
5073
5074         (FindMembers): Handle events separately by returning the MyEventBuilder of the event,
5075         not the EventBuilder.
5076
5077 2001-12-18  Miguel de Icaza  <miguel@ximian.com>
5078
5079         * cs-tokenizer.cs: Add support for defines.
5080         Add support for #if, #elif, #else, #endif
5081
5082         (eval_var): evaluates a variable.
5083         (eval): stubbed for evaluating functions.
5084
5085         * cs-parser.jay: Pass the defines information
5086
5087         * driver.cs: Add --define command line option.
5088
5089         * decl.cs: Move MemberCore here.
5090
5091         Make it the base class for DeclSpace.  This allows us to catch and
5092         report 108 and 109 for everything now.
5093
5094         * class.cs (TypeContainer.Define): Extract all the members
5095         before populating and emit the warning 108 (new keyword required
5096         to override) instead of having each member implement this.
5097
5098         (MemberCore.Define): New abstract method, we will be using this in
5099         the warning reporting engine in Populate.
5100
5101         (Operator.Define): Adjust to new MemberCore protocol.
5102
5103         * const.cs (Const): This does not derive from Expression, it is a
5104         temporary object we use to create fields, it is a MemberCore.
5105
5106         * class.cs (Method.Define): Allow the entry point to be in a
5107         specific class.
5108
5109         * driver.cs: Rewrite the argument handler to clean it up a bit.
5110
5111         * rootcontext.cs: Made it just an auxiliary namespace feature by
5112         making everything static.
5113
5114         * driver.cs: Adapt code to use RootContext type name instead of
5115         instance variable.
5116
5117         * delegate.cs: Remove RootContext argument.
5118
5119         * class.cs: (Struct, TypeContainer, Class): Remove RootContext
5120         argument.
5121
5122         * class.cs (Event.Define): The lookup can fail.
5123
5124         * cs-tokenizer.cs: Begin implementation of pre-procesor.
5125
5126         * expression.cs: Resolve the this instance before invoking the code.
5127
5128 2001-12-17  Miguel de Icaza  <miguel@ximian.com>
5129
5130         * cs-parser.jay: Add a production in element_access that allows
5131         the thing to become a "type" reference.  This way we can parse
5132         things like "(string [])" as a type.
5133
5134         Note that this still does not handle the more complex rules of
5135         casts.
5136
5137
5138         * delegate.cs (Delegate.Populate): Register the delegage constructor builder here.
5139
5140         * ecore.cs: (CopyNewMethods): new utility function used to
5141         assemble the list of methods from running FindMembers.
5142
5143         (MemberLookup): Rework FindMembers so that
5144
5145 2001-12-16  Miguel de Icaza  <miguel@ximian.com>
5146
5147         * class.cs (TypeContainer): Remove Delegates who fail to be
5148         defined.
5149
5150         * delegate.cs (Populate): Verify that we dont get null return
5151         values.   TODO: Check for AsAccessible.
5152
5153         * cs-parser.jay: Use basename to emit error 574 (destructor should
5154         have the same name as container class), not the full name.
5155
5156         * cs-tokenizer.cs (adjust_int): Fit the integer in the best
5157         possible representation.
5158
5159         Also implements integer type suffixes U and L.
5160
5161 2001-12-15  Miguel de Icaza  <miguel@ximian.com>
5162
5163         * expression.cs (ArrayCreation.DoResolve): We need to do the
5164         argument resolution *always*.
5165
5166         * decl.cs: Make this hold the namespace.  Hold the root context as
5167         well.
5168         (LookupType): Move here.
5169
5170         * enum.cs, class.cs, interface.cs: Adapt to new hierarchy.
5171
5172         * location.cs (Row, Name): Fixed the code, it was always returning
5173         references to the first file.
5174
5175         * interface.cs: Register properties defined through interfaces.
5176
5177         * driver.cs: Add support for globbing on the command line
5178
5179         * class.cs (Field): Make it derive from MemberCore as well.
5180         (Event): ditto.
5181
5182 2001-12-15  Ravi Pratap  <ravi@ximian.com>
5183
5184         * class.cs (Event::Define): Check that the type of the event is a delegate
5185         type else flag error #66.
5186
5187         Also, re-use TypeContainer.MethodModifiersValid here too as the rules are the
5188         same.
5189
5190         * attribute.cs (DefinePInvokeMethod): Handle named arguments and process
5191         values of EntryPoint, CharSet etc etc.
5192
5193         Pass in the values to TypeBuilder.DefinePInvokeMethod; determine Type etc neatly.
5194
5195         * class.cs (FindMembers): If a method is in transit, its MethodBuilder will
5196         be null and we should ignore this. I am not sure if this is really clean. Apparently,
5197         there's no way of avoiding hitting this because the call is coming from SimpleName.DoResolve,
5198         which needs this to do its work.
5199
5200         * ../errors/cs0066.cs : Add.
5201
5202 2001-12-14  Miguel de Icaza  <miguel@ximian.com>
5203
5204         * typemanager.cs: (GetPropertyGetter, GetPropertyGetter): New
5205         helper functions.
5206
5207         * class.cs: (MethodSignature.MethodSignature): Removed hack that
5208         clears out the parameters field.
5209         (MemberSignatureCompare): Cleanup
5210
5211         (MemberCore): New base class used to share code between MethodCore
5212         and Property.
5213
5214         (RegisterRequiredImplementations) BindingFlags.Public requires
5215         either BindingFlags.Instace or Static.  Use instance here.
5216
5217         (Property): Refactored code to cope better with the full spec.
5218
5219         * parameter.cs (GetParameterInfo): Return an empty array instead
5220         of null on error.
5221
5222         * class.cs (Property): Abstract or extern properties have no bodies.
5223
5224         * parameter.cs (GetParameterInfo): return a zero-sized array.
5225
5226         * class.cs (TypeContainer.MethodModifiersValid): Move all the
5227         method modifier validation to the typecontainer so we can reuse
5228         this on properties.
5229
5230         (MethodCore.ParameterTypes): return an empty sized array of types.
5231
5232         (Property.Define): Test property modifier validity.
5233
5234         Add tests for sealed/override too.
5235
5236         (Method.Emit): abstract or extern methods have no bodies.
5237
5238 2001-12-14  Ravi Pratap  <ravi@ximian.com>
5239
5240         * class.cs (Method.IsPInvoke): Get rid of it as it is an expensive
5241         thing.
5242
5243         (Method::Define, ::Emit): Modify accordingly.
5244
5245         * expression.cs (Invocation::OverloadResolve): Handle error # 121.
5246
5247         (ArrayCreation::MakeByteBlob): Handle floats and doubles.
5248
5249         * makefile: Pass in /unsafe.
5250
5251 2001-12-13  Miguel de Icaza  <miguel@ximian.com>
5252
5253         * class.cs (MakeKey): Kill routine.
5254
5255         * class.cs (TypeContainer.Define): Correctly define explicit
5256         method implementations (they require the full interface name plus
5257         the method name).
5258
5259         * typemanager.cs: Deply the PtrHashtable here and stop using the
5260         lame keys.  Things work so much better.
5261
5262         This of course broke everyone who depended on `RegisterMethod' to
5263         do the `test for existance' test.  This has to be done elsewhere.
5264
5265         * support.cs (PtrHashtable): A hashtable that avoid comparing with
5266         the object stupid Equals method (because, that like fails all over
5267         the place).  We still do not use it.
5268
5269         * class.cs (TypeContainer.SetRequiredInterface,
5270         TypeContainer.RequireMethods): Killed these two routines and moved
5271         all the functionality to RegisterRequiredImplementations.
5272
5273         (TypeContainer.RegisterRequiredImplementations): This routine now
5274         registers all the implementations required in an array for the
5275         interfaces and abstract methods.  We use an array of structures
5276         which can be computed ahead of time to reduce memory usage and we
5277         also assume that lookups are cheap as most classes will not
5278         implement too many interfaces.
5279
5280         We also avoid creating too many MethodSignatures.
5281
5282         (TypeContainer.IsInterfaceMethod): Update and optionally does not
5283         clear the "pending" bit if we find that there are problems with
5284         the declaration.
5285
5286         (TypeContainer.VerifyPendingMethods): Update to report errors of
5287         methods that look like implementations but are not.
5288
5289         (TypeContainer.Define): Add support for explicit interface method
5290         implementation.
5291
5292 2001-12-12  Miguel de Icaza  <miguel@ximian.com>
5293
5294         * typemanager.cs: Keep track of the parameters here instead of
5295         being a feature of the TypeContainer.
5296
5297         * class.cs: Drop the registration of parameters here, as
5298         InterfaceMethods are also interface declarations.
5299
5300         * delegate.cs: Register methods with the TypeManager not only with
5301         the TypeContainer.  This code was buggy.
5302
5303         * interface.cs: Full registation here.
5304
5305 2001-12-11  Miguel de Icaza  <miguel@ximian.com>
5306
5307         * expression.cs: Remove reducer for binary expressions, it can not
5308         be done this way.
5309
5310         * const.cs: Put here the code that used to go into constant.cs
5311
5312         * constant.cs: Put here the code for constants, this is a new base
5313         class for Literals.
5314
5315         * literal.cs: Make Literal derive from Constant.
5316
5317 2001-12-09  Miguel de Icaza  <miguel@ximian.com>
5318
5319         * statement.cs (Return.Emit): Report error 157 if the user
5320         attempts to return from a finally block.
5321
5322         (Return.Emit): Instead of emitting a return, jump to the end of
5323         the function.
5324
5325         * codegen.cs (EmitContext): ReturnValue, ReturnLabel: new
5326         LocalBuilder to store the result of the function.  ReturnLabel is
5327         the target where we jump.
5328
5329
5330 2001-12-09  Radek Doulik  <rodo@ximian.com>
5331
5332         * cs-parser.jay: remember alias in current namespace
5333
5334         * ecore.cs (SimpleName::DoResolve): use aliases for types or
5335         namespaces
5336
5337         * class.cs (LookupAlias): lookup alias in my_namespace
5338
5339         * namespace.cs (UsingAlias): add alias, namespace_or_type pair to
5340         aliases hashtable
5341         (LookupAlias): lookup alias in this and if needed in parent
5342         namespaces
5343
5344 2001-12-08  Miguel de Icaza  <miguel@ximian.com>
5345
5346         * support.cs:
5347
5348         * rootcontext.cs: (ModuleBuilder) Made static, first step into
5349         making things static.  I need this to avoid passing the
5350         TypeContainer when calling ParameterType.
5351
5352         * support.cs (InternalParameters.ParameterType): Remove ugly hack
5353         that did string manipulation to compute the type and then call
5354         GetType.  Use Parameter.ParameterType instead.
5355
5356         * cs-tokenizer.cs: Consume the suffix for floating values.
5357
5358         * expression.cs (ParameterReference): figure out whether this is a
5359         reference parameter or not.  Kill an extra variable by computing
5360         the arg_idx during emission.
5361
5362         * parameter.cs (Parameters.GetParameterInfo): New overloaded
5363         function that returns whether a parameter is an out/ref value or not.
5364
5365         (Parameter.ParameterType): The type of the parameter (base,
5366         without ref/out applied).
5367
5368         (Parameter.Resolve): Perform resolution here.
5369         (Parameter.ExternalType): The full type (with ref/out applied).
5370
5371         * statement.cs (Using.Emit, Using.EmitExpression): Implement
5372         support for expressions on the using statement.
5373
5374 2001-12-07  Miguel de Icaza  <miguel@ximian.com>
5375
5376         * statement.cs (Using.EmitLocalVariableDecls): Split the
5377         localvariable handling of the using statement.
5378
5379         (Block.EmitMeta): Keep track of variable count across blocks.  We
5380         were reusing slots on separate branches of blocks.
5381
5382         (Try.Emit): Emit the general code block, we were not emitting it.
5383
5384         Check the type of the declaration to be an IDisposable or
5385         something that can be implicity converted to it.
5386
5387         Emit conversions if required.
5388
5389         * ecore.cs (EmptyExpression): New utility class.
5390         (Expression.ImplicitConversionExists): New utility function.
5391
5392 2001-12-06  Miguel de Icaza  <miguel@ximian.com>
5393
5394         * statement.cs (Using): Implement.
5395
5396         * expression.cs (LocalVariableReference): Support read only variables.
5397
5398         * statement.cs: Remove the explicit emit for the Leave opcode.
5399         (VariableInfo): Add a readonly field.
5400
5401 2001-12-05  Miguel de Icaza  <miguel@ximian.com>
5402
5403         * ecore.cs (ConvCast): new class used to encapsulate the various
5404         explicit integer conversions that works in both checked and
5405         unchecked contexts.
5406
5407         (Expression.ConvertNumericExplicit): Use new ConvCast class to
5408         properly generate the overflow opcodes.
5409
5410 2001-12-04  Miguel de Icaza  <miguel@ximian.com>
5411
5412         * statement.cs: The correct type for the EmptyExpression is the
5413         element_type, not the variable type.  Ravi pointed this out.
5414
5415 2001-12-04  Ravi Pratap  <ravi@ximian.com>
5416
5417         * class.cs (Method::Define): Handle PInvoke methods specially
5418         by using DefinePInvokeMethod instead of the usual one.
5419
5420         * attribute.cs (DefinePInvokeMethod): Implement as this is what is called
5421         above to do the task of extracting information and defining the method.
5422
5423 2001-12-04  Ravi Pratap  <ravi@ximian.com>
5424
5425         * expression.cs (ArrayCreation::EmitStaticInitializers): Get rid
5426         of the condition for string type.
5427
5428         (Emit): Move that here.
5429
5430         (ArrayCreation::CheckIndices): Keep string literals in their expression
5431         form.
5432
5433         (EmitDynamicInitializers): Handle strings appropriately.
5434
5435 2001-12-04  Miguel de Icaza  <miguel@ximian.com>
5436
5437         * codegen.cs (EmitContext): Replace multiple variables with a
5438         single pointer to the current Switch statement.
5439
5440         * statement.cs (GotoDefault, Switch): Adjust to cleaned up
5441         EmitContext.
5442
5443 2001-12-03  Miguel de Icaza  <miguel@ximian.com>
5444
5445         * statement.cs
5446
5447         * statement.cs (GotoDefault), cs-parser.jay: Implement `goto
5448         default'.
5449
5450         (Foreach.Emit): Foreach on arrays was not setting
5451         up the loop variables (for break/continue).
5452
5453         (GotoCase): Semi-implented.
5454
5455 2001-12-03  Ravi Pratap  <ravi@ximian.com>
5456
5457         * attribute.cs (CheckAttribute): Handle system attributes by using
5458         Attribute.GetAttributes to examine information we need.
5459
5460         (GetValidPlaces): Same here.
5461
5462         * class.cs (Method::Define): Catch invalid use of extern and abstract together.
5463
5464         * typemanager.cs (dllimport_type): Core type for System.DllImportAttribute.
5465
5466         * class.cs (Method.IsPinvoke): Used to determine if we are a PInvoke method.
5467
5468         (Method::Define): Set appropriate flags if we have a DllImport attribute.
5469
5470         (Method::Emit): Handle the case when we are a PInvoke method.
5471
5472 2001-12-03  Miguel de Icaza  <miguel@ximian.com>
5473
5474         * expression.cs: Use ResolveWithSimpleName on compound names.
5475
5476 2001-12-02  Ravi Pratap  <ravi@ximian.com>
5477
5478         * constant.cs (EmitConstant): Make sure we resolve the associated expression
5479         before trying to reduce it.
5480
5481         * typemanager.cs (RegisterConstant, LookupConstant): Implement.
5482
5483         * constant.cs (LookupConstantValue): Implement.
5484
5485         (EmitConstant): Use the above in emitting the constant.
5486
5487         * expression.cs (MemberAccess::ResolveMemberAccess): Handle constants
5488         that are user-defined by doing a LookupConstantValue on them.
5489
5490         (SimpleName::DoResolve): When we have a FieldExpr, cope with constants
5491         too, like above.
5492
5493 2001-11-29  Miguel de Icaza  <miguel@ximian.com>
5494
5495         * expression.cs (BaseAccess, BaseIndexer): Also split this out.
5496
5497         (BaseAccess.DoResolve): Implement.
5498
5499         (MemberAccess.DoResolve): Split this routine into a
5500         ResolveMemberAccess routine that can be used independently
5501
5502 2001-11-28  Miguel de Icaza  <miguel@ximian.com>
5503
5504         * expression.cs (Probe, Is, As): Split Probe in two classes Is and
5505         As that share bits of the implementation.  Is returns a boolean,
5506         while As returns the Type that is being probed.
5507
5508 2001-12-01  Ravi Pratap  <ravi@ximian.com>
5509
5510         * enum.cs (LookupEnumValue): Re-write various bits, return an object value
5511         instead of a Literal - much easier.
5512
5513         (EnumInTransit): Remove - utterly useless :-)
5514
5515         (Populate): Re-write bits - remove duplicate code etc. The code is much neater now.
5516
5517         * expression.cs (MemberLookup): Cope with user-defined enums when they are in transit.
5518
5519         * enum.cs (LookupEnumValue): Auto-compute next values by going down the dependency
5520         chain when we have no associated expression.
5521
5522 2001-11-30  Ravi Pratap  <ravi@ximian.com>
5523
5524         * constant.cs (Define): Use Location while reporting the errror.
5525
5526         Also emit a warning when 'new' is used and there is no inherited
5527         member to hide.
5528
5529         * enum.cs (EnumInTransit): Used to tell if an enum type is in the process of being
5530         populated.
5531
5532         (LookupEnumValue): Implement to lookup an enum member's value and define it
5533         if necessary.
5534
5535         (Populate): Re-write accordingly to use the above routine.
5536
5537 2001-11-27  Miguel de Icaza  <miguel@ximian.com>
5538
5539         * expression.cs (This): Fix prototype for DoResolveLValue to
5540         override the base class DoResolveLValue.
5541
5542         * cs-parser.cs: Report errors cs574 and cs575 (destructor
5543         declarations)
5544
5545         * ecore.cs (FieldExpr.EmitAssign): Handle value types specially
5546         (we need to load the address of the field here).  This fixes
5547         test-22.
5548
5549         (FieldExpr.DoResolveLValue): Call the DoResolve
5550         function to initialize the Instance expression.
5551
5552         * statement.cs (Foreach.Emit): Fix the bug where we did not invoke
5553         correctly the GetEnumerator operation on a value type.
5554
5555         * cs-parser.jay: Add more simple parsing error catches.
5556
5557         * statement.cs (Switch): Add support for string switches.
5558         Handle null specially.
5559
5560         * literal.cs (NullLiteral): Make NullLiteral objects singletons.
5561
5562 2001-11-28  Ravi Pratap  <ravi@ximian.com>
5563
5564         * cs-parser.jay (local_constant_declaration): Use declare_local_constant.
5565
5566         (declare_local_constant): New helper function.
5567
5568         * statement.cs (AddConstant): Keep a separate record of constants
5569
5570         (IsConstant): Implement to determine if a variable is a constant.
5571
5572         (GetConstantExpression): Implement.
5573
5574         * expression.cs (LocalVariableReference): Handle the case when it is a constant.
5575
5576         * statement.cs (IsVariableDefined): Re-write.
5577
5578 2001-11-27  Ravi Pratap  <ravi@ximian.com>
5579
5580         * class.cs (TypeContainer::FindMembers): Look for constants
5581         in the case when we are looking for MemberTypes.Field
5582
5583         * expression.cs (MemberAccess::DoResolve): Check that in the
5584         case we are a FieldExpr and a Literal, we are not being accessed
5585         by an instance reference.
5586
5587         * cs-parser.jay (local_constant_declaration): Implement.
5588
5589         (declaration_statement): Implement for constant declarations.
5590
5591 2001-11-26  Miguel de Icaza  <miguel@ximian.com>
5592
5593         * statement.cs (Switch): Catch double defaults.
5594
5595         (Switch): More work on the switch() statement
5596         implementation.  It works for integral values now, need to finish
5597         string support.
5598
5599
5600 2001-11-24  Miguel de Icaza  <miguel@ximian.com>
5601
5602         * ecore.cs (Expression.ConvertIntLiteral): New function to convert
5603         integer literals into other integer literals.  To be used by
5604         switch.
5605
5606 2001-11-24  Ravi Pratap  <ravi@ximian.com>
5607
5608         * expression.cs (ArrayCreation): Get rid of ArrayExprs : we save
5609         some memory.
5610
5611         (EmitDynamicInitializers): Cope with the above since we extract data
5612         directly from ArrayData now.
5613
5614         (ExpectInitializers): Keep track of whether initializers are mandatory
5615         or not.
5616
5617         (Bounds): Make it a hashtable to prevent the same dimension being
5618         recorded for every element in that dimension.
5619
5620         (EmitDynamicInitializers): Fix bug which prevented the Set array method
5621         from being found.
5622
5623         Also fix bug which was causing the indices to be emitted in the reverse
5624         order.
5625
5626 2001-11-24  Miguel de Icaza  <miguel@ximian.com>
5627
5628         * expression.cs (ArrayCreation): Implement the bits that Ravi left
5629         unfinished.  They do not work, because the underlying code is
5630         sloppy.
5631
5632 2001-11-22  Miguel de Icaza  <miguel@ximian.com>
5633
5634         * cs-parser.jay: Remove bogus fixme.
5635
5636         * statement.cs (Switch, SwitchSection, SwithLabel): Started work
5637         on Switch statement.
5638
5639 2001-11-23  Ravi Pratap  <ravi@ximian.com>
5640
5641         * typemanager.cs (IsDelegateType, IsEnumType): Fix logic to determine
5642         the same.
5643
5644         * expression.cs (ArrayCreation::CheckIndices): Get rid of the require_constant
5645         parameter. Apparently, any expression is allowed.
5646
5647         (ValidateInitializers): Update accordingly.
5648
5649         (CheckIndices): Fix some tricky bugs thanks to recursion.
5650
5651         * delegate.cs (NewDelegate::DoResolve): Re-write large portions as
5652         I was being completely brain-dead.
5653
5654         (VerifyMethod, VerifyApplicability, VerifyDelegate): Make static
5655         and re-write acordingly.
5656
5657         (DelegateInvocation): Re-write accordingly.
5658
5659         * expression.cs (ArrayCreation::Emit): Handle string initialization separately.
5660
5661         (MakeByteBlob): Handle types more correctly.
5662
5663         * expression.cs (ArrayCreation:Emit): Write preliminary code to do
5664         initialization from expressions but it is incomplete because I am a complete
5665         Dodo :-|
5666
5667 2001-11-22  Miguel de Icaza  <miguel@ximian.com>
5668
5669         * statement.cs (If.Emit): Fix a bug that generated incorrect code
5670         on If.  Basically, we have to return `true' (ie, we do return to
5671         our caller) only if both branches of the if return.
5672
5673         * expression.cs (Binary.Emit): LogicalOr and LogicalAnd are
5674         short-circuit operators, handle them as short circuit operators.
5675
5676         (Cast.DoResolve): Resolve type.
5677         (Cast.Cast): Take an expression as the target type.
5678
5679         * cs-parser.jay (cast_expression): Remove old hack that only
5680         allowed a limited set of types to be handled.  Now we take a
5681         unary_expression and we resolve to a type during semantic
5682         analysis.
5683
5684         Use the grammar productions from Rhys to handle casts (this is
5685         not complete like Rhys syntax yet, we fail to handle that corner
5686         case that C# has regarding (-x), but we will get there.
5687
5688 2001-11-22  Ravi Pratap  <ravi@ximian.com>
5689
5690         * class.cs (EmitFieldInitializer): Take care of the case when we have a
5691         field which is an array type.
5692
5693         * cs-parser.jay (declare_local_variables): Support array initialization too.
5694
5695         * typemanager.cs (MakeKey): Implement.
5696
5697         (everywhere): Use the above appropriately.
5698
5699         * cs-parser.jay (for_statement): Update for array initialization while
5700         declaring variables.
5701
5702         * ecore.cs : The error message was correct, it's the variable's names that
5703         were misleading ;-) Make the code more readable.
5704
5705         (MemberAccess::DoResolve): Fix the code which handles Enum literals to set
5706         the correct type etc.
5707
5708         (ConvertExplicit): Handle Enum types by examining the underlying type.
5709
5710 2001-11-21  Ravi Pratap  <ravi@ximian.com>
5711
5712         * parameter.cs (GetCallingConvention): Always return
5713         CallingConventions.Standard for now.
5714
5715 2001-11-22  Miguel de Icaza  <miguel@ximian.com>
5716
5717         * expression.cs (Binary.ResolveOperator): Update the values of `l'
5718         and `r' after calling DoNumericPromotions.
5719
5720         * ecore.cs: Fix error message (the types were in the wrong order).
5721
5722         * statement.cs (Foreach.ProbeCollectionType): Need to pass
5723         BindingFlags.Instance as well
5724
5725         * ecore.cs (Expression.TryImplicitIntConversion): Wrap the result
5726         implicit int literal conversion in an empty cast so that we
5727         propagate the right type upstream.
5728
5729         (UnboxCast): new class used to unbox value types.
5730         (Expression.ConvertExplicit): Add explicit type conversions done
5731         by unboxing.
5732
5733         (Expression.ImplicitNumericConversion): Oops, forgot to test for
5734         the target type before applying the implicit LongLiterals to ULong
5735         literal cast.
5736
5737 2001-11-21  Miguel de Icaza  <miguel@ximian.com>
5738
5739         * cs-parser.jay (for_statement): Reworked the way For works: now
5740         we declare manually any variables that are introduced in
5741         for_initializer to solve the problem of having out-of-band code
5742         emition (that is what got for broken).
5743
5744         (declaration_statement): Perform the actual variable declaration
5745         that used to be done in local_variable_declaration here.
5746
5747         (local_variable_declaration): Do not declare anything, just pass
5748         the information on a DictionaryEntry
5749
5750 2001-11-20  Ravi Pratap  <ravi@ximian.com>
5751
5752         * expression.cs (ArrayCreation::CheckIndices): The story continues :-) Complete
5753         re-write of the logic to now make it recursive.
5754
5755         (UpdateIndices): Re-write accordingly.
5756
5757         Store element data in a separate ArrayData list in the above methods.
5758
5759         (MakeByteBlob): Implement to dump the array data into a byte array.
5760
5761 2001-11-19  Ravi Pratap  <ravi@ximian.com>
5762
5763         * expression.cs (ArrayCreation): Factor out some code from ValidateInitializers
5764         into CheckIndices.
5765
5766         * constant.cs (Define): Implement.
5767
5768         (EmitConstant): Re-write fully.
5769
5770         Pass in location info.
5771
5772         * class.cs (Populate, Emit): Call Constant::Define and Constant::EmitConstant
5773         respectively.
5774
5775         * cs-parser.jay (constant_declarator): Use VariableDeclaration instead of
5776         DictionaryEntry since we need location info too.
5777
5778         (constant_declaration): Update accordingly.
5779
5780         * expression.cs (ArrayCreation): Make ValidateInitializers simpler by factoring
5781         code into another method : UpdateIndices.
5782
5783 2001-11-18  Ravi Pratap  <ravi@ximian.com>
5784
5785         * expression.cs (ArrayCreation::ValidateInitializers): Update to perform
5786         some type checking etc.
5787
5788 2001-11-17  Ravi Pratap  <ravi@ximian.com>
5789
5790         * expression.cs (ArrayCreation::ValidateInitializers): Implement
5791         bits to provide dimension info if the user skips doing that.
5792
5793         Update second constructor to store the rank correctly.
5794
5795 2001-11-16  Ravi Pratap  <ravi@ximian.com>
5796
5797         * expression.cs (ArrayCreation::ValidateInitializers): Poke around
5798         and try to implement.
5799
5800         * ../errors/cs0150.cs : Add.
5801
5802         * ../errors/cs0178.cs : Add.
5803
5804 2001-11-16  Miguel de Icaza  <miguel@ximian.com>
5805
5806         * statement.cs: Implement foreach on multi-dimensional arrays.
5807
5808         * parameter.cs (Parameters.GetParameterByName): Also lookup the
5809         name of the params argument.
5810
5811         * expression.cs: Use EmitStoreOpcode to get the right opcode while
5812         initializing the array.
5813
5814         (ArrayAccess.EmitStoreOpcode): move the opcode generation here, so
5815         we can use this elsewhere.
5816
5817         * statement.cs: Finish implementation of foreach for single
5818         dimension arrays.
5819
5820         * cs-parser.jay: Use an out-of-band stack to pass information
5821         around, I wonder why I need this.
5822
5823         foreach_block: Make the new foreach_block the current_block.
5824
5825         * parameter.cs (Parameters.GetEmptyReadOnlyParameters): New
5826         function used to return a static Parameters structure.  Used for
5827         empty parameters, as those are created very frequently.
5828
5829         * cs-parser.jay, class.cs: Use GetEmptyReadOnlyParameters
5830
5831 2001-11-15  Ravi Pratap  <ravi@ximian.com>
5832
5833         * interface.cs : Default modifier is private, not public. The
5834         make verify test passes again.
5835
5836 2001-11-15  Ravi Pratap  <ravi@ximian.com>
5837
5838         * support.cs (ReflectionParameters): Fix logic to determine
5839         whether the last parameter is a params one. Test 9 passes again.
5840
5841         * delegate.cs (Populate): Register the builders we define with
5842         RegisterParameterForBuilder. Test 19 passes again.
5843
5844         * cs-parser.jay (property_declaration): Reference $6 instead
5845         of $$ to get at the location.
5846
5847         (indexer_declaration): Similar stuff.
5848
5849         (attribute): Ditto.
5850
5851         * class.cs (Property): Register parameters for the Get and Set methods
5852         if they exist. Test 23 passes again.
5853
5854         * expression.cs (ArrayCreation::Emit): Pass null for the method in the
5855         call to EmitArguments as we are sure there aren't any params arguments.
5856         Test 32 passes again.
5857
5858         * suppor.cs (ParameterDesc, ParameterModifier): Fix trivial bug causing
5859         IndexOutOfRangeException.
5860
5861         * class.cs (Property::Define): Register property using TypeManager.RegisterProperty
5862         Test 33 now passes again.
5863
5864 2001-11-15  Miguel de Icaza  <miguel@ximian.com>
5865
5866         * cs-parser.jay: Kill horrendous hack ($??? = lexer.Location) that
5867         broke a bunch of things.  Will have to come up with a better way
5868         of tracking locations.
5869
5870         * statement.cs: Implemented foreach for single dimension arrays.
5871
5872 2001-11-09  Miguel de Icaza  <miguel@ximian.com>
5873
5874         * enum.cs (Enum.Emit): Delay the lookup of loc until we run into
5875         an error.  This removes the lookup from the critical path.
5876
5877         * cs-parser.jay: Removed use of temporary_loc, which is completely
5878         broken.
5879
5880 2001-11-14  Miguel de Icaza  <miguel@ximian.com>
5881
5882         * support.cs (ReflectionParameters.ParameterModifier): Report
5883         whether the argument is a PARAMS argument or not.
5884
5885         * class.cs: Set the attribute `ParamArrayAttribute' on the
5886         parameter argument.
5887
5888         * typemanager.cs: Define param_array_type (ParamArrayAttribute)
5889         and cons_param_array_attribute (ConstructorInfo for
5890         ParamArrayAttribute).,
5891
5892         * codegen.cs: Emit the return using the `Return' statement, that
5893         way we can report the error correctly for missing return values.
5894
5895         * class.cs (Method.Emit): Clean up.
5896
5897         * expression.cs (Argument.Resolve): Take another argument: the
5898         location where this argument is used.  Notice that this is not
5899         part of the "Argument" class as to reduce the size of the
5900         structure (we know the approximate location anyways).
5901
5902         Test if the argument is a variable-reference, if not, then
5903         complain with a 206.
5904
5905         (Argument.Emit): Emit addresses of variables.
5906
5907         (Argument.FullDesc): Simplify.
5908
5909         (Invocation.DoResolve): Update for Argument.Resolve.
5910
5911         (ElementAccess.DoResolve): ditto.
5912
5913         * delegate.cs (DelegateInvocation.Emit): Invocation of Invoke
5914         method should be virtual, as this method is always virtual.
5915
5916         (NewDelegate.DoResolve): Update for Argument.Resolve.
5917
5918         * class.cs (ConstructorInitializer.DoResolve): ditto.
5919
5920         * attribute.cs (Attribute.Resolve): ditto.
5921
5922 2001-11-13  Miguel de Icaza  <miguel@ximian.com>
5923
5924         * statement.cs (Foreach.Emit): Use EmitAssign instead of Store.
5925
5926         * expression.cs (ParameterReference): Drop IStackStorage and implement
5927         IAssignMethod instead.
5928
5929         (LocalVariableReference): ditto.
5930
5931         * ecore.cs (FieldExpr): Drop IStackStorage and implement
5932         IAssignMethod instead.
5933
5934 2001-11-13  Miguel de Icaza <miguel@ximian.com>
5935
5936         * parameter.cs, expression.cs, class.cs, ecore.cs: Made all
5937         enumerations that are used in heavily used structures derive from
5938         byte in a laughable and pathetic attempt to reduce memory usage.
5939         This is the kind of pre-optimzations that you should not do at
5940         home without adult supervision.
5941
5942         * expression.cs (UnaryMutator): New class, used to handle ++ and
5943         -- separatedly from the other unary operators.  Cleans up the
5944         code, and kills the ExpressionStatement dependency in Unary.
5945
5946         (Unary): Removed `method' and `Arguments' from this class, making
5947         it smaller, and moving it all to SimpleCall, so I can reuse this
5948         code in other locations and avoid creating a lot of transient data
5949         strucutres when not required.
5950
5951         * cs-parser.jay: Adjust for new changes.
5952
5953 2001-11-11  Miguel de Icaza  <miguel@ximian.com>
5954
5955         * enum.cs (Enum.Populate): If there is a failure during
5956         definition, return
5957
5958         * cs-parser.jay (opt_enum_base): we used to catch type errors
5959         here, but this is really incorrect.  The type error should be
5960         catched during semantic analysis.
5961
5962 2001-12-11  Ravi Pratap  <ravi@ximian.com>
5963
5964         * cs-parser.jay (operator_declarator, conversion_operator_declarator): Set
5965         current_local_parameters as expected since I, in my stupidity, had forgotten
5966         to do this :-)
5967
5968         * attribute.cs (GetValidPlaces): Fix stupid bug.
5969
5970         * class.cs (Method::Emit): Perform check on applicability of attributes.
5971
5972         (Constructor::Emit): Ditto.
5973
5974         (Field::Emit): Ditto.
5975
5976         (Field.Location): Store location information.
5977
5978         (Property, Event, Indexer, Operator): Ditto.
5979
5980         * cs-parser.jay (field_declaration): Pass in location for each field.
5981
5982         * ../errors/cs0592.cs : Add.
5983
5984 2001-11-12  Ravi Pratap  <ravi@ximian.com>
5985
5986         * typemanager.cs (attribute_usage_type): New static member for System.AttributeUsage.
5987
5988         (InitCoreTypes): Update accordingly.
5989
5990         (RegisterAttrType, LookupAttr): Implement.
5991
5992         * attribute.cs (Attribute.Targets, AllowMultiple, Inherited): New fields to hold
5993         info about the same.
5994
5995         (Resolve): Update to populate the above as necessary.
5996
5997         (Error592): Helper.
5998
5999         (GetValidPlaces): Helper to the above.
6000
6001         (CheckAttribute): Implement to perform validity of attributes on declarative elements.
6002
6003         * class.cs (TypeContainer::Emit): Update attribute emission code to perform checking etc.
6004
6005 2001-11-12  Ravi Pratap  <ravi@ximian.com>
6006
6007         * attribute.cs (Attribute::Resolve): Expand to handle named arguments too.
6008
6009         * ../errors/cs0617.cs : Add.
6010
6011 2001-11-11  Ravi Pratap  <ravi@ximian.com>
6012
6013         * enum.cs (Emit): Rename to Populate to be more consistent with what
6014         we expect it to do and when exactly it is called.
6015
6016         * class.cs, rootcontext.cs : Update accordingly.
6017
6018         * typemanager.cs (RegisterField, GetValue): Workarounds for the fact that
6019         FieldInfo.GetValue does not work on dynamic types ! S.R.E lameness strikes again !
6020
6021         * enum.cs (Populate): Register fields with TypeManager.RegisterField.
6022
6023         * expression.cs (MemberAccess.DoResolve): Adjust code to obtain the value
6024         of a fieldinfo using the above, when dealing with a FieldBuilder.
6025
6026 2001-11-10  Ravi Pratap  <ravi@ximian.com>
6027
6028         * ../errors/cs0031.cs : Add.
6029
6030         * ../errors/cs1008.cs : Add.
6031
6032         * ../errrors/cs0543.cs : Add.
6033
6034         * enum.cs (DefineEnum): Check the underlying type and report an error if not a valid
6035         enum type.
6036
6037         (FindMembers): Implement.
6038
6039         * typemanager.cs (FindMembers): Re-write to call the appropriate methods for
6040         enums and delegates too.
6041
6042         (enum_types): Rename to builder_to_enum.
6043
6044         (delegate_types): Rename to builder_to_delegate.
6045
6046         * delegate.cs (FindMembers): Implement.
6047
6048 2001-11-09  Ravi Pratap  <ravi@ximian.com>
6049
6050         * typemanager.cs (IsEnumType): Implement.
6051
6052         * enum.cs (Emit): Re-write parts to account for the underlying type
6053         better and perform checking etc.
6054
6055         (GetNextDefaultValue): Helper to ensure we don't overshoot max value
6056         of the underlying type.
6057
6058         * literal.cs (GetValue methods everywhere): Perform bounds checking and return
6059         value
6060
6061         * enum.cs (error31): Helper to report error #31.
6062
6063         * cs-parser.jay (enum_declaration): Store location of each member too.
6064
6065         * enum.cs (member_to_location): New hashtable.
6066
6067         (AddEnumMember): Update location hashtable.
6068
6069         (Emit): Use the location of each member while reporting errors.
6070
6071 2001-11-09  Miguel de Icaza  <miguel@ximian.com>
6072
6073         * cs-parser.jay: A for_initializer if is a
6074         local_variable_declaration really ammount to have an implicit
6075         block with the variable declaration and no initializer for for.
6076
6077         * statement.cs (For.Emit): Cope with null initializers.
6078
6079         This fixes the infinite loop on for initializers.
6080
6081 2001-11-08  Miguel de Icaza  <miguel@ximian.com>
6082
6083         * enum.cs: More cleanup.
6084
6085         * ecore.cs: Remove dead code.
6086
6087         * class.cs (Property.Emit): More simplification.
6088         (Event.Emit): ditto.
6089
6090         Reworked to have less levels of indentation.
6091
6092 2001-11-08  Ravi Pratap  <ravi@ximian.com>
6093
6094         * class.cs (Property): Emit attributes.
6095
6096         (Field): Ditto.
6097
6098         (Event): Ditto.
6099
6100         (Indexer): Ditto.
6101
6102         (Operator): Ditto.
6103
6104         * enum.cs (Emit): Ditto.
6105
6106         * rootcontext.cs (ResolveTree, EmitCode, CloseTypes): Do the same for
6107         Enums too.
6108
6109         * class.cs (Field, Event, etc.): Move attribute generation into the
6110         Emit method everywhere.
6111
6112         * enum.cs (Enum): Revamp to use the same definition semantics as delegates so
6113         we have a DefineEnum, CloseEnum etc. The previous way of doing things was not right
6114         as we had no way of defining nested enums !
6115
6116         * rootcontext.cs : Adjust code accordingly.
6117
6118         * typemanager.cs (AddEnumType): To keep track of enum types separately.
6119
6120 2001-11-07  Ravi Pratap  <ravi@ximian.com>
6121
6122         * expression.cs (EvalConstantExpression): Move into ecore.cs
6123
6124         * enum.cs (Enum): Rename some members and make them public and readonly
6125         according to our convention.
6126
6127         * modifiers.cs (EnumAttr): Implement as we need to set only visibility flags,
6128         nothing else.
6129
6130         * enum.cs (Enum::Define): Use the above instead of TypeAttr.
6131
6132         (Enum::Emit): Write a simple version for now which doesn't try to compute
6133         expressions. I shall modify this to be more robust in just a while.
6134
6135         * class.cs (TypeContainer::Emit): Make sure we include Enums too.
6136
6137         (TypeContainer::CloseType): Create the Enum types too.
6138
6139         * attribute.cs (Resolve): Use the new Reduce method instead of EvalConstantExpression.
6140
6141         * expression.cs (EvalConstantExpression): Get rid of completely.
6142
6143         * enum.cs (Enum::Emit): Use the new expression reducer. Implement assigning
6144         user-defined values and other cases.
6145
6146         (IsValidEnumLiteral): Helper function.
6147
6148         * expression.cs (ExprClassfromMemberInfo): Modify to not do any literalizing
6149         out there in the case we had a literal FieldExpr.
6150
6151         (MemberAccess:DoResolve): Do the literalizing of the FieldExpr here.
6152
6153         (Literalize): Revamp a bit to take two arguments.
6154
6155         (EnumLiteral): New class which derives from Literal to wrap enum literals.
6156
6157 2001-11-06  Ravi Pratap  <ravi@ximian.com>
6158
6159         * cs-parser.jay (compilation_unit): Remove extra opt_attributes for now.
6160
6161         * expression.cs (ArrayCreation::ValidateInitializers): Implement.
6162
6163         (Resolve): Use the above to ensure we have proper initializers.
6164
6165 2001-11-05  Ravi Pratap  <ravi@ximian.com>
6166
6167         * expression.cs (Expression::EvalConstantExpression): New method to
6168         evaluate constant expressions.
6169
6170         * attribute.cs (Attribute::Resolve): Modify bits to use the above function.
6171
6172 2001-11-07  Miguel de Icaza  <miguel@ximian.com>
6173
6174         * expression.cs (ArrayCreation.Emit): Some bits to initialize data
6175         in an array.
6176
6177         (Binary.ResolveOperator): Handle operator != (object a, object b)
6178         and operator == (object a, object b);
6179
6180         (Binary.DoNumericPromotions): Indicate whether the numeric
6181         promotion was possible.
6182
6183         (ArrayAccess.DoResolve, ArrayAccess.Emit, ArrayAccess.EmitAssign):
6184         Implement.
6185
6186         Made the ArrayAccess implement interface IAssignMethod instead of
6187         IStackStore as the order in which arguments are passed reflects
6188         this.
6189
6190         * assign.cs: Instead of using expr.ExprClass to select the way of
6191         assinging, probe for the IStackStore/IAssignMethod interfaces.
6192
6193         * typemanager.cs: Load InitializeArray definition.
6194
6195         * rootcontext.cs (RootContext.MakeStaticData): Used to define
6196         static data that can be used to initialize arrays.
6197
6198 2001-11-05  Miguel de Icaza  <miguel@ximian.com>
6199
6200         * expression.cs: Handle operator== and operator!= for booleans.
6201
6202         (Conditioal.Reduce): Implement reducer for the ?: operator.
6203
6204         (Conditional.Resolve): Implement dead code elimination.
6205
6206         (Binary.Resolve): Catch string literals and return a new
6207         concatenated string.
6208
6209         (Unary.Reduce): Implement reduction of unary expressions.
6210
6211         * ecore.cs: Split out the expression core handling here.
6212
6213         (Expression.Reduce): New method used to perform constant folding
6214         and CSE.  This is needed to support constant-expressions.
6215
6216         * statement.cs (Statement.EmitBoolExpression): Pass true and false
6217         targets, and optimize for !x.
6218
6219 2001-11-04  Ravi Pratap  <ravi@ximian.com>
6220
6221         * attribute.cs (Attribute::Resolve): Implement guts. Note that resolution
6222         of an attribute gives us a CustomAttributeBuilder which we use accordingly to
6223         set custom atttributes.
6224
6225         * literal.cs (Literal::GetValue): New abstract method to return the actual
6226         value of the literal, cast as an object.
6227
6228         (*Literal): Implement GetValue method.
6229
6230         * cs-parser.jay (positional_argument_list, named_argument_list): Add not just plain
6231         expressions to the arraylist but objects of type Argument.
6232
6233         * class.cs (TypeContainer::Emit): Emit our attributes too.
6234
6235         (Method::Emit, Constructor::Emit): Ditto.
6236
6237         * cs-parser.jay (constructor_declaration): Set attributes too, which we seemed
6238         to be ignoring earlier.
6239
6240 2001-11-03  Ravi Pratap  <ravi@ximian.com>
6241
6242         * attribute.cs (AttributeSection::Define): Implement to do the business
6243         of constructing a CustomAttributeBuilder.
6244
6245         (Attribute): New trivial class. Increases readability of code.
6246
6247         * cs-parser.jay : Update accordingly.
6248
6249         (positional_argument_list, named_argument_list, named_argument): New rules
6250
6251         (attribute_arguments): Use the above so that we are more correct.
6252
6253 2001-11-02  Ravi Pratap  <ravi@ximian.com>
6254
6255         * expression.cs (Invocation::IsParamsMethodApplicable): Implement
6256         to perform all checks for a method with a params parameter.
6257
6258         (Invocation::OverloadResolve): Update to use the above method and therefore
6259         cope correctly with params method invocations.
6260
6261         * support.cs (InternalParameters::ParameterDesc): Provide a desc for
6262         params too.
6263
6264         * class.cs (ConstructorInitializer::Resolve): Make sure we look for Non-public
6265         constructors in our parent too because we can't afford to miss out on
6266         protected ones ;-)
6267
6268         * attribute.cs (AttributeSection): New name for the class Attribute
6269
6270         Other trivial changes to improve readability.
6271
6272         * cs-parser.jay (opt_attributes, attribute_section etc.): Modify to
6273         use the new class names.
6274
6275 2001-11-01  Ravi Pratap  <ravi@ximian.com>
6276
6277         * class.cs (Method::Define): Complete definition for params types too
6278
6279         (Indexer::Define): Ditto.
6280
6281         * support.cs (InternalParameters::ParameterType, ParameterDesc, ParameterModifier):
6282         Cope everywhere with a request for info about the array parameter.
6283
6284 2001-11-01  Ravi Pratap  <ravi@ximian.com>
6285
6286         * tree.cs (RecordNamespace): Fix up to check for the correct key.
6287
6288         * cs-parser.jay (GetQualifiedIdentifier): New Helper method used in
6289         local_variable_type to extract the string corresponding to the type.
6290
6291         (local_variable_type): Fixup the action to use the new helper method.
6292
6293         * codegen.cs : Get rid of RefOrOutParameter, it's not the right way to
6294         go.
6295
6296         * expression.cs : Clean out code which uses the above.
6297
6298 2001-10-31  Ravi Pratap  <ravi@ximian.com>
6299
6300         * typemanager.cs (RegisterMethod): Check if we already have an existing key
6301         and bale out if necessary by returning a false.
6302
6303         (RegisterProperty): Ditto.
6304
6305         * class.cs (everywhere): Check the return value from TypeManager.RegisterMethod
6306         and print out appropriate error messages.
6307
6308         * interface.cs (everywhere): Ditto.
6309
6310         * cs-parser.jay (property_declaration, event_declaration, indexer_declaration): Pass
6311         location to constructor.
6312
6313         * class.cs (Property, Event, Indexer): Update accordingly.
6314
6315         * ../errors/cs111.cs : Added.
6316
6317         * expression.cs (Invocation::IsApplicable): New static method to determine applicability
6318         of a method, as laid down by the spec.
6319
6320         (Invocation::OverloadResolve): Use the above method.
6321
6322 2001-10-31  Ravi Pratap  <ravi@ximian.com>
6323
6324         * support.cs (InternalParameters): Get rid of crap taking in duplicate info. We
6325         now take a TypeContainer and a Parameters object.
6326
6327         (ParameterData): Modify return type of ParameterModifier method to be
6328         Parameter.Modifier and not a string.
6329
6330         (ReflectionParameters, InternalParameters): Update accordingly.
6331
6332         * expression.cs (Argument::GetParameterModifier): Same here.
6333
6334         * support.cs (InternalParameters::ParameterType): Find a better way of determining
6335         if we are a ref/out parameter. Actually, the type shouldn't be holding the '&'
6336         symbol in it at all so maybe this is only for now.
6337
6338 2001-10-30  Ravi Pratap  <ravi@ximian.com>
6339
6340         * support.cs (InternalParameters): Constructor now takes an extra argument
6341         which is the actual Parameters class.
6342
6343         (ParameterDesc): Update to provide info on ref/out modifiers.
6344
6345         * class.cs (everywhere): Update call to InternalParameters to pass in
6346         the second argument too.
6347
6348         * support.cs (ParameterData): Add ParameterModifier, which is a method
6349         to return the modifier info [ref/out etc]
6350
6351         (InternalParameters, ReflectionParameters): Implement the above.
6352
6353         * expression.cs (Argument::ParameterModifier): Similar function to return
6354         info about the argument's modifiers.
6355
6356         (Invocation::OverloadResolve): Update to take into account matching modifiers
6357         too.
6358
6359         * class.cs (Indexer::Define): Actually define a Parameter object and put it onto
6360         a new SetFormalParameters object which we pass to InternalParameters.
6361
6362 2001-10-30  Ravi Pratap  <ravi@ximian.com>
6363
6364         * expression.cs (NewArray): Merge into the ArrayCreation class.
6365
6366 2001-10-29  Ravi Pratap  <ravi@ximian.com>
6367
6368         * expression.cs (NewArray): Merge classes NewBuiltinArray and
6369         NewUserdefinedArray into one as there wasn't much of a use in having
6370         two separate ones.
6371
6372         * expression.cs (Argument): Change field's name to ArgType from Type.
6373
6374         (Type): New readonly property which returns the proper type, taking into
6375         account ref/out modifiers.
6376
6377         (everywhere): Adjust code accordingly for the above.
6378
6379         * codegen.cs (EmitContext.RefOrOutParameter): New field to determine
6380         whether we are emitting for a ref or out parameter.
6381
6382         * expression.cs (Argument::Emit): Use the above field to set the state.
6383
6384         (LocalVariableReference::Emit): Update to honour the flag and emit the
6385         right stuff.
6386
6387         * parameter.cs (Attributes): Set the correct flags for ref parameters.
6388
6389         * expression.cs (Argument::FullDesc): New function to provide a full desc.
6390
6391         * support.cs (ParameterData): Add method ParameterDesc to the interface.
6392
6393         (ReflectionParameters, InternalParameters): Implement the above method.
6394
6395         * expression.cs (Invocation::OverloadResolve): Use the new desc methods in
6396         reporting errors.
6397
6398         (Invocation::FullMethodDesc): Ditto.
6399
6400 2001-10-29  Miguel de Icaza  <miguel@ximian.com>
6401
6402         * cs-parser.jay: Add extra production for the second form of array
6403         creation.
6404
6405         * expression.cs (ArrayCreation): Update to reflect the above
6406         change.
6407
6408         * Small changes to prepare for Array initialization.
6409
6410 2001-10-28  Miguel de Icaza  <miguel@ximian.com>
6411
6412         * typemanager.cs (ImplementsInterface): interface might be null;
6413         Deal with this problem;
6414
6415         Also, we do store negative hits on the cache (null values), so use
6416         this instead of calling t.GetInterfaces on the type everytime.
6417
6418 2001-10-28  Ravi Pratap  <ravi@ximian.com>
6419
6420         * typemanager.cs (IsBuiltinType): New method to help determine the same.
6421
6422         * expression.cs (New::DoResolve): Get rid of array creation code and instead
6423         split functionality out into different classes.
6424
6425         (New::FormArrayType): Move into NewBuiltinArray.
6426
6427         (Invocation::EmitArguments): Get rid of the MethodBase argument. Appears
6428         quite useless.
6429
6430         (NewBuiltinArray): New class to handle creation of built-in arrays.
6431
6432         (NewBuiltinArray::DoResolve): Implement guts of array creation. Also take into
6433         account creation of one-dimensional arrays.
6434
6435         (::Emit): Implement to use Newarr and Newobj opcodes accordingly.
6436
6437         (NewUserdefinedArray::DoResolve): Implement.
6438
6439         * cs-parser.jay (local_variable_type): Fix up to add the rank to the variable too.
6440
6441         * typemanager.cs (AddModule): Used to add a ModuleBuilder to the list of modules
6442         we maintain inside the TypeManager. This is necessary to perform lookups on the
6443         module builder.
6444
6445         (LookupType): Update to perform GetType on the module builders too.
6446
6447         * driver.cs (Driver): Add the ModuleBuilder to the list maintained by the TypeManager.
6448
6449         * exprssion.cs (NewUserdefinedArray::Emit): Implement.
6450
6451 2001-10-23  Ravi Pratap  <ravi@ximian.com>
6452
6453         * expression.cs (New::DoResolve): Implement guts of array creation.
6454
6455         (New::FormLookupType): Rename to FormArrayType and modify ever so slightly.
6456
6457 2001-10-27  Miguel de Icaza  <miguel@ximian.com>
6458
6459         * expression.cs: Fix bug I introduced lsat night that broke
6460         Delegates.
6461
6462         (Expression.Resolve): Report a 246 error (can not resolve name)
6463         if we find a SimpleName in the stream.
6464
6465         (Expression.ResolveLValue): Ditto.
6466
6467         (Expression.ResolveWithSimpleName): This function is a variant of
6468         ResolveName, this one allows SimpleNames to be returned without a
6469         warning.  The only consumer of SimpleNames is MemberAccess
6470
6471 2001-10-26  Miguel de Icaza  <miguel@ximian.com>
6472
6473         * expression.cs (Invocation::DoResolve): Catch SimpleNames that
6474         might arrive here.  I have my doubts that this is correct.
6475
6476         * statement.cs (Lock): Implement lock statement.
6477
6478         * cs-parser.jay: Small fixes to support `lock' and `using'
6479
6480         * cs-tokenizer.cs: Remove extra space
6481
6482         * driver.cs: New flag --checked, allows to turn on integer math
6483         checking.
6484
6485         * typemanger.cs: Load methodinfos for Threading.Monitor.Enter and
6486         Threading.Monitor.Exit
6487
6488 2001-10-23  Miguel de Icaza  <miguel@ximian.com>
6489
6490         * expression.cs (IndexerAccess::DoResolveLValue): Set the
6491         Expression Class to be IndexerAccess.
6492
6493         Notice that Indexer::DoResolve sets the eclass to Value.
6494
6495 2001-10-22  Miguel de Icaza  <miguel@ximian.com>
6496
6497         * class.cs (TypeContainer::Emit): Emit code for indexers.
6498
6499         * assign.cs (IAssignMethod): New interface implemented by Indexers
6500         and Properties for handling assignment.
6501
6502         (Assign::Emit): Simplify and reuse code.
6503
6504         * expression.cs (IndexerAccess, PropertyExpr): Implement
6505         IAssignMethod, clean up old code.
6506
6507 2001-10-22  Ravi Pratap  <ravi@ximian.com>
6508
6509         * typemanager.cs (ImplementsInterface): New method to determine if a type
6510         implements a given interface. Provides a nice cache too.
6511
6512         * expression.cs (ImplicitReferenceConversion): Update checks to use the above
6513         method.
6514
6515         (ConvertReferenceExplicit): Ditto.
6516
6517         * delegate.cs (Delegate::Populate): Update to define the parameters on the
6518         various methods, with correct names etc.
6519
6520         * class.cs (Operator::OpType): New members Operator.UnaryPlus and
6521         Operator.UnaryNegation.
6522
6523         * cs-parser.jay (operator_declarator): Be a little clever in the case where
6524         we have a unary plus or minus operator.
6525
6526         * expression.cs (Unary): Rename memebers of Operator enum to UnaryPlus and
6527         UnaryMinus.
6528
6529         * everywhere : update accordingly.
6530
6531         * everywhere : Change Negate and BitComplement to LogicalNot and OnesComplement
6532         respectively.
6533
6534         * class.cs (Method::Define): For the case where we are implementing a method
6535         inherited from an interface, we need to set the MethodAttributes.Final flag too.
6536         Also set MethodAttributes.NewSlot and MethodAttributes.HideBySig.
6537
6538 2001-10-21  Ravi Pratap  <ravi@ximian.com>
6539
6540         * interface.cs (FindMembers): Implement to work around S.R.E
6541         lameness.
6542
6543         * typemanager.cs (IsInterfaceType): Implement.
6544
6545         (FindMembers): Update to handle interface types too.
6546
6547         * expression.cs (ImplicitReferenceConversion): Re-write bits which
6548         use IsAssignableFrom as that is not correct - it doesn't work.
6549
6550         * delegate.cs (DelegateInvocation): Derive from ExpressionStatement
6551         and accordingly override EmitStatement.
6552
6553         * expression.cs (ConvertReferenceExplicit): Re-write similary, this time
6554         using the correct logic :-)
6555
6556 2001-10-19  Ravi Pratap  <ravi@ximian.com>
6557
6558         * ../errors/cs-11.cs : Add to demonstrate error -11
6559
6560 2001-10-17  Miguel de Icaza  <miguel@ximian.com>
6561
6562         * assign.cs (Assign::Resolve): Resolve right hand side first, and
6563         then pass this as a hint to ResolveLValue.
6564
6565         * expression.cs (FieldExpr): Add Location information
6566
6567         (FieldExpr::LValueResolve): Report assignment to readonly
6568         variable.
6569
6570         (Expression::ExprClassFromMemberInfo): Pass location information.
6571
6572         (Expression::ResolveLValue): Add new method that resolves an
6573         LValue.
6574
6575         (Expression::DoResolveLValue): Default invocation calls
6576         DoResolve.
6577
6578         (Indexers): New class used to keep track of indexers in a given
6579         Type.
6580
6581         (IStackStore): Renamed from LValue, as it did not really describe
6582         what this did.  Also ResolveLValue is gone from this interface and
6583         now is part of Expression.
6584
6585         (ElementAccess): Depending on the element access type
6586
6587         * typemanager.cs: Add `indexer_name_type' as a Core type
6588         (System.Runtime.CompilerServices.IndexerNameAttribute)
6589
6590         * statement.cs (Goto): Take a location.
6591
6592 2001-10-18  Ravi Pratap  <ravi@ximian.com>
6593
6594         * delegate.cs (Delegate::VerifyDelegate): New method to verify
6595         if two delegates are compatible.
6596
6597         (NewDelegate::DoResolve): Update to take care of the case when
6598         we instantiate a delegate from another delegate.
6599
6600         * typemanager.cs (FindMembers): Don't even try to look up members
6601         of Delegate types for now.
6602
6603 2001-10-18  Ravi Pratap  <ravi@ximian.com>
6604
6605         * delegate.cs (NewDelegate): New class to take care of delegate
6606         instantiation.
6607
6608         * expression.cs (New): Split the delegate related code out into
6609         the NewDelegate class.
6610
6611         * delegate.cs (DelegateInvocation): New class to handle delegate
6612         invocation.
6613
6614         * expression.cs (Invocation): Split out delegate related code into
6615         the DelegateInvocation class.
6616
6617 2001-10-17  Ravi Pratap  <ravi@ximian.com>
6618
6619         * expression.cs (New::DoResolve): Implement delegate creation fully
6620         and according to the spec.
6621
6622         (New::DoEmit): Update to handle delegates differently.
6623
6624         (Invocation::FullMethodDesc): Fix major stupid bug thanks to me
6625         because of which we were printing out arguments in reverse order !
6626
6627         * delegate.cs (VerifyMethod): Implement to check if the given method
6628         matches the delegate.
6629
6630         (FullDelegateDesc): Implement.
6631
6632         (VerifyApplicability): Implement.
6633
6634         * expression.cs (Invocation::DoResolve): Update to accordingly handle
6635         delegate invocations too.
6636
6637         (Invocation::Emit): Ditto.
6638
6639         * ../errors/cs1593.cs : Added.
6640
6641         * ../errors/cs1594.cs : Added.
6642
6643         * delegate.cs (InstanceExpression, TargetMethod): New properties.
6644
6645 2001-10-16  Ravi Pratap  <ravi@ximian.com>
6646
6647         * typemanager.cs (intptr_type): Core type for System.IntPtr
6648
6649         (InitCoreTypes): Update for the same.
6650
6651         (iasyncresult_type, asynccallback_type): Ditto.
6652
6653         * delegate.cs (Populate): Fix to use System.Intptr as it is indeed
6654         correct.
6655
6656         * typemanager.cs (AddDelegateType): Store a pointer to the Delegate class
6657         too.
6658
6659         * delegate.cs (ConstructorBuilder, InvokeBuilder, ...): New members to hold
6660         the builders for the 4 members of a delegate type :-)
6661
6662         (Populate): Define the BeginInvoke and EndInvoke methods on the delegate
6663         type.
6664
6665         * expression.cs (New::DoResolve): Implement guts for delegate creation.
6666
6667         * ../errors/errors.txt : Update for an error (-11) which only we catch :-)
6668
6669 2001-10-15  Miguel de Icaza  <miguel@ximian.com>
6670
6671         * statement.cs (Break::Emit): Implement.
6672         (Continue::Emit): Implement.
6673
6674         (For::Emit): Track old being/end loops;  Set Begin loop, ack end loop
6675         (While::Emit): Track old being/end loops;  Set Begin loop, ack end loop
6676         (Do::Emit): Track old being/end loops;  Set Begin loop, ack end loop
6677         (Foreach::Emit): Track old being/end loops;  Set Begin loop, ack
6678         end loop
6679
6680         * codegen.cs (EmitContext::LoopEnd, EmitContext::LoopBegin): New
6681         properties that track the label for the current loop (begin of the
6682         loop and end of the loop).
6683
6684 2001-10-15  Ravi Pratap  <ravi@ximian.com>
6685
6686         * delegate.cs (Emit): Get rid of it as there doesn't seem to be any ostensible
6687         use of emitting anything at all.
6688
6689         * class.cs, rootcontext.cs : Get rid of calls to the same.
6690
6691         * delegate.cs (DefineDelegate): Make sure the class we define is also sealed.
6692
6693         (Populate): Define the constructor correctly and set the implementation
6694         attributes.
6695
6696         * typemanager.cs (delegate_types): New hashtable to hold delegates that
6697         have been defined.
6698
6699         (AddDelegateType): Implement.
6700
6701         (IsDelegateType): Implement helper method.
6702
6703         * delegate.cs (DefineDelegate): Use AddDelegateType instead of AddUserType.
6704
6705         * expression.cs (New::DoResolve): Check if we are trying to instantiate a delegate type
6706         and accordingly handle it.
6707
6708         * delegate.cs (Populate): Take TypeContainer argument.
6709         Implement bits to define the Invoke method. However, I still haven't figured out
6710         how to take care of the native int bit :-(
6711
6712         * cs-parser.jay (delegate_declaration): Fixed the bug that I had introduced :-)
6713         Qualify the name of the delegate, not its return type !
6714
6715         * expression.cs (ImplicitReferenceConversion): Implement guts of implicit array
6716         conversion.
6717
6718         (StandardConversionExists): Checking for array types turns out to be recursive.
6719
6720         (ConvertReferenceExplicit): Implement array conversion.
6721
6722         (ExplicitReferenceConversionExists): New method to determine precisely that :-)
6723
6724 2001-10-12  Ravi Pratap  <ravi@ximian.com>
6725
6726         * cs-parser.jay (delegate_declaration): Store the fully qualified
6727         name as it is a type declaration.
6728
6729         * delegate.cs (ReturnType, Name): Rename members to these. Make them
6730         readonly.
6731
6732         (DefineDelegate): Renamed from Define. Does the same thing essentially,
6733         as TypeContainer::DefineType.
6734
6735         (Populate): Method in which all the definition of the various methods (Invoke)
6736         etc is done.
6737
6738         (Emit): Emit any code, if necessary. I am not sure about this really, but let's
6739         see.
6740
6741         (CloseDelegate): Finally creates the delegate.
6742
6743         * class.cs (TypeContainer::DefineType): Update to define delegates.
6744         (Populate, Emit and CloseType): Do the same thing here too.
6745
6746         * rootcontext.cs (ResolveTree, PopulateTypes, EmitCode, CloseTypes): Include
6747         delegates in all these operations.
6748
6749 2001-10-14  Miguel de Icaza  <miguel@ximian.com>
6750
6751         * expression.cs: LocalTemporary: a new expression used to
6752         reference a temporary that has been created.
6753
6754         * assign.cs: Handle PropertyAccess back here, so that we can
6755         provide the proper semantic access to properties.
6756
6757         * expression.cs (Expression::ConvertReferenceExplicit): Implement
6758         a few more explicit conversions.
6759
6760         * modifiers.cs: `NEW' modifier maps to HideBySig.
6761
6762         * expression.cs (PropertyExpr): Make this into an
6763         ExpressionStatement, and support the EmitStatement code path.
6764
6765         Perform get/set error checking, clean up the interface.
6766
6767         * assign.cs: recognize PropertyExprs as targets, and if so, turn
6768         them into toplevel access objects.
6769
6770 2001-10-12  Miguel de Icaza  <miguel@ximian.com>
6771
6772         * expression.cs: PropertyExpr::PropertyExpr: use work around the
6773         SRE.
6774
6775         * typemanager.cs: Keep track here of our PropertyBuilders again to
6776         work around lameness in SRE.
6777
6778 2001-10-11  Miguel de Icaza  <miguel@ximian.com>
6779
6780         * expression.cs (LValue::LValueResolve): New method in the
6781         interface, used to perform a second resolution pass for LValues.
6782
6783         (This::DoResolve): Catch the use of this in static methods.
6784
6785         (This::LValueResolve): Implement.
6786
6787         (This::Store): Remove warning, assigning to `this' in structures
6788         is
6789
6790         (Invocation::Emit): Deal with invocation of
6791         methods on value types.  We need to pass the address to structure
6792         methods rather than the object itself.  (The equivalent code to
6793         emit "this" for structures leaves the entire structure on the
6794         stack instead of a pointer to it).
6795
6796         (ParameterReference::DoResolve): Compute the real index for the
6797         argument based on whether the method takes or not a `this' pointer
6798         (ie, the method is static).
6799
6800         * codegen.cs (EmitContext::GetTemporaryStorage): Used to store
6801         value types returned from functions when we need to invoke a
6802         method on the sturcture.
6803
6804
6805 2001-10-11  Ravi Pratap  <ravi@ximian.com>
6806
6807         * class.cs (TypeContainer::DefineType): Method to actually do the business of
6808         defining the type in the Modulebuilder or Typebuilder. This is to take
6809         care of nested types which need to be defined on the TypeBuilder using
6810         DefineNestedMethod.
6811
6812         (TypeContainer::GetClassBases): Implement. Essentially the code from the
6813         methods in RootContext, only ported to be part of TypeContainer.
6814
6815         (TypeContainer::GetInterfaceOrClass): Ditto.
6816
6817         (TypeContainer::LookupInterfaceOrClass, ::MakeFQN): Ditto.
6818
6819         * interface.cs (Interface::DefineInterface): New method. Does exactly
6820         what RootContext.CreateInterface did earlier, only it takes care of nested types
6821         too.
6822
6823         (Interface::GetInterfaces): Move from RootContext here and port.
6824
6825         (Interface::GetInterfaceByName): Same here.
6826
6827         * rootcontext.cs (ResolveTree): Re-write.
6828
6829         (PopulateTypes): Re-write.
6830
6831         * class.cs (TypeContainer::Populate): Populate nested types too.
6832         (TypeContainer::Emit): Emit nested members too.
6833
6834         * typemanager.cs (AddUserType): Do not make use of the FullName property,
6835         instead just use the name argument passed in as it is already fully
6836         qualified.
6837
6838         (FindMembers): Check in the Builders to TypeContainer mapping instead of the name
6839         to TypeContainer mapping to see if a type is user-defined.
6840
6841         * class.cs (TypeContainer::CloseType): Implement.
6842
6843         (TypeContainer::DefineDefaultConstructor): Use Basename, not Name while creating
6844         the default constructor.
6845
6846         (TypeContainer::Populate): Fix minor bug which led to creating default constructors
6847         twice.
6848
6849         (Constructor::IsDefault): Fix up logic to determine if it is the default constructor
6850
6851         * interface.cs (CloseType): Create the type here.
6852
6853         * rootcontext.cs (CloseTypes): Re-write to recursively close types by running through
6854         the hierarchy.
6855
6856         Remove all the methods which are now in TypeContainer.
6857
6858 2001-10-10  Ravi Pratap  <ravi@ximian.com>
6859
6860         * delegate.cs (Define): Re-write bits to define the delegate
6861         correctly.
6862
6863 2001-10-10  Miguel de Icaza  <miguel@ximian.com>
6864
6865         * makefile: Renamed the compiler to `mcs.exe' instead of compiler.exe
6866
6867         * expression.cs (ImplicitReferenceConversion): handle null as well
6868         as a source to convert to any reference type.
6869
6870         * statement.cs (Return): Perform any implicit conversions to
6871         expected return type.
6872
6873         Validate use of return statement.
6874
6875         * codegen.cs (EmitContext): Pass the expected return type here.
6876
6877         * class.cs (Method, Constructor, Property): Pass expected return
6878         type to EmitContext.
6879
6880 2001-10-09  Miguel de Icaza  <miguel@ximian.com>
6881
6882         * expression.cs: Make DoResolve take an EmitContext instead of a
6883         TypeContainer.
6884
6885         Replaced `l' and `location' for `loc', for consistency.
6886
6887         (Error, Warning): Remove unneeded Tc argument.
6888
6889         * assign.cs, literal.cs, constant.cs: Update to new calling
6890         convention.
6891
6892         * codegen.cs: EmitContext now contains a flag indicating whether
6893         code is being generated in a static method or not.
6894
6895         * cs-parser.jay: DecomposeQI, new function that replaces the old
6896         QualifiedIdentifier.  Now we always decompose the assembled
6897         strings from qualified_identifier productions into a group of
6898         memberaccesses.
6899
6900 2001-10-08  Miguel de Icaza  <miguel@ximian.com>
6901
6902         * rootcontext.cs: Deal with field-less struct types correctly now
6903         by passing the size option to Define Type.
6904
6905         * class.cs: Removed hack that created one static field.
6906
6907 2001-10-07  Miguel de Icaza  <miguel@ximian.com>
6908
6909         * statement.cs: Moved most of the code generation here.
6910
6911 2001-10-09  Ravi Pratap  <ravi@ximian.com>
6912
6913         * expression.cs (New::DoResolve): Revert changes for array creation, doesn't
6914         seem very right.
6915
6916         (ElementAccess): Remove useless bits for now - keep checks as the spec
6917         says.
6918
6919 2001-10-08  Ravi Pratap  <ravi@ximian.com>
6920
6921         * expression.cs (ElementAccess::DoResolve): Remove my crap code
6922         and start performing checks according to the spec.
6923
6924 2001-10-07  Ravi Pratap  <ravi@ximian.com>
6925
6926         * cs-parser.jay (type_suffix*): Remove - they are redundant. Use
6927         rank_specifiers instead.
6928
6929         (rank_specifiers): Change the order in which the rank specifiers are stored
6930
6931         (local_variable_declaration): Use opt_rank_specifier instead of type_suffixes.
6932
6933         * expression.cs (ElementAccess): Implement the LValue interface too.
6934
6935 2001-10-06  Ravi Pratap  <ravi@ximian.com>
6936
6937         * expression.cs (ConvertExplicitStandard): Add. Same as ConvertExplicit
6938         except that user defined conversions are not included.
6939
6940         (UserDefinedConversion): Update to use the ConvertExplicitStandard to
6941         perform the conversion of the return type, if necessary.
6942
6943         (New::DoResolve): Check whether we are creating an array or an object
6944         and accordingly do the needful.
6945
6946         (New::Emit): Same here.
6947
6948         (New::DoResolve): Implement guts of array creation.
6949
6950         (New::FormLookupType): Helper function.
6951
6952 2001-10-07  Miguel de Icaza  <miguel@ximian.com>
6953
6954         * codegen.cs: Removed most of the code generation here, and move the
6955         corresponding code generation bits to the statement classes.
6956
6957         Added support for try/catch/finalize and throw.
6958
6959         * cs-parser.jay: Added support for try/catch/finalize.
6960
6961         * class.cs: Catch static methods having the flags override,
6962         virtual or abstract.
6963
6964         * expression.cs (UserCast): This user cast was not really doing
6965         what it was supposed to do.  Which is to be born in fully resolved
6966         state.  Parts of the resolution were being performed at Emit time!
6967
6968         Fixed this code.
6969
6970 2001-10-05  Miguel de Icaza  <miguel@ximian.com>
6971
6972         * expression.cs: Implicity convert the result from UserCast.
6973
6974 2001-10-05  Ravi Pratap  <ravi@ximian.com>
6975
6976         * expression.cs (Expression::FindMostEncompassingType): Fix bug which
6977         prevented it from working correctly.
6978
6979         (ConvertExplicit): Make the first try, a call to ConvertImplicitStandard, not
6980         merely ConvertImplicit.
6981
6982 2001-10-05  Miguel de Icaza  <miguel@ximian.com>
6983
6984         * typemanager.cs: Make the LookupTypeContainer function static,
6985         and not per-instance.
6986
6987         * class.cs: Make static FindMembers (the one that takes a Type
6988         argument).
6989
6990         * codegen.cs: Add EmitForeach here.
6991
6992         * cs-parser.jay: Make foreach a toplevel object instead of the
6993         inline expansion, as we need to perform semantic analysis on it.
6994
6995 2001-10-05  Ravi Pratap  <ravi@ximian.com>
6996
6997         * expression.cs (Expression::ImplicitUserConversion): Rename to
6998         UserDefinedConversion.
6999
7000         (Expression::UserDefinedConversion): Take an extra argument specifying
7001         whether we look for explicit user conversions too.
7002
7003         (Expression::ImplicitUserConversion): Make it a call to UserDefinedConversion.
7004
7005         (UserDefinedConversion): Incorporate support for user defined explicit conversions.
7006
7007         (ExplicitUserConversion): Make it a call to UserDefinedConversion
7008         with the appropriate arguments.
7009
7010         * cs-parser.jay (cast_expression): Record location too.
7011
7012         * expression.cs (Cast): Record location info.
7013
7014         (Expression::ConvertExplicit): Take location argument.
7015
7016         (UserImplicitCast): Change name to UserCast. Take an extra constructor argument
7017         to determine if we are doing explicit conversions.
7018
7019         (UserCast::Emit): Update accordingly.
7020
7021         (Expression::ConvertExplicit): Report an error if everything fails.
7022
7023         * ../errors/cs0030.cs : Add.
7024
7025 2001-10-04  Miguel de Icaza  <miguel@ximian.com>
7026
7027         * modifiers.cs: If the ABSTRACT keyword is present, also set the
7028         virtual and newslot bits.
7029
7030         * class.cs (TypeContainer::RegisterRequiredImplementations):
7031         Record methods we need.
7032
7033         (TypeContainer::MakeKey): Helper function to make keys for
7034         MethodBases, since the Methodbase key is useless.
7035
7036         (TypeContainer::Populate): Call RegisterRequiredImplementations
7037         before defining the methods.
7038
7039         Create a mapping for method_builders_to_methods ahead of time
7040         instead of inside a tight loop.
7041
7042         (::RequireMethods):  Accept an object as the data to set into the
7043         hashtable so we can report interface vs abstract method mismatch.
7044
7045 2001-10-03  Miguel de Icaza  <miguel@ximian.com>
7046
7047         * report.cs: Make all of it static.
7048
7049         * rootcontext.cs: Drop object_type and value_type computations, as
7050         we have those in the TypeManager anyways.
7051
7052         Drop report instance variable too, now it is a global.
7053
7054         * driver.cs: Use try/catch on command line handling.
7055
7056         Add --probe option to debug the error reporting system with a test
7057         suite.
7058
7059         * report.cs: Add support for exiting program when a probe
7060         condition is reached.
7061
7062 2001-10-03  Ravi Pratap  <ravi@ximian.com>
7063
7064         * expression.cs (Binary::DoNumericPromotions): Fix the case when
7065         we do a forcible conversion regardless of type, to check if
7066         ForceConversion returns a null.
7067
7068         (Binary::error19): Use location to report error.
7069
7070         (Unary::error23): Use location here too.
7071
7072         * ../errors/cs0019.cs : Check in.
7073
7074         * ../errors/cs0023.cs : Check in.
7075
7076         * expression.cs (Expression.MemberLookup): Return null for a rather esoteric
7077         case of a non-null MethodInfo object with a length of 0 !
7078
7079         (Binary::ResolveOperator): Flag error if overload resolution fails to find
7080         an applicable member - according to the spec :-)
7081         Also fix logic to find members in base types.
7082
7083         (Unary::ResolveOperator): Same here.
7084
7085         (Unary::report23): Change name to error23 and make first argument a TypeContainer
7086         as I was getting thoroughly confused between this and error19 :-)
7087
7088         * expression.cs (Expression::ImplicitUserConversion): Re-write fully
7089         (::FindMostEncompassedType): Implement.
7090         (::FindMostEncompassingType): Implement.
7091         (::StandardConversionExists): Implement.
7092
7093         (UserImplicitCast): Re-vamp. We now need info about most specific
7094         source and target types so that we can do the necessary conversions.
7095
7096         (Invocation::MakeUnionSet): Completely re-write to make sure we form a proper
7097         mathematical union with no duplicates.
7098
7099 2001-10-03  Miguel de Icaza  <miguel@ximian.com>
7100
7101         * rootcontext.cs (RootContext::PopulateTypes): Populate containers
7102         in order from base classes to child classes, so that we can in
7103         child classes look up in our parent for method names and
7104         attributes (required for handling abstract, virtual, new, override
7105         constructs: we need to instrospect our base class, and if we dont
7106         populate the classes in order, the introspection might be
7107         incorrect.  For example, a method could query its parent before
7108         the parent has any methods and would determine that the parent has
7109         no abstract methods (while it could have had them)).
7110
7111         (RootContext::CreateType): Record the order in which we define the
7112         classes.
7113
7114 2001-10-02  Miguel de Icaza  <miguel@ximian.com>
7115
7116         * class.cs (TypeContainer::Populate): Also method definitions can
7117         fail now, keep track of this.
7118
7119         (TypeContainer::FindMembers): Implement support for
7120         DeclaredOnly/noDeclaredOnly flag.
7121
7122         (Constructor::Emit) Return the ConstructorBuilder.
7123
7124         (Method::Emit) Return the MethodBuilder.
7125         Check for abstract or virtual methods to be public.
7126
7127         * rootcontext.cs (RootContext::CreateType): Register all the
7128         abstract methods required for the class to be complete and the
7129         interface methods that must be implemented.
7130
7131         * cs-parser.jay: Report error 501 (method requires body if it is
7132         not marked abstract or extern).
7133
7134         * expression.cs (TypeOf::Emit): Implement.
7135
7136         * typemanager.cs: runtime_handle_type, new global type.
7137
7138         * class.cs (Property::Emit): Generate code for properties.
7139
7140 2001-10-02  Ravi Pratap  <ravi@ximian.com>
7141
7142         * expression.cs (Unary::ResolveOperator): Find operators on base type
7143         too - we now conform exactly to the spec.
7144
7145         (Binary::ResolveOperator): Same here.
7146
7147         * class.cs (Operator::Define): Fix minor quirk in the tests.
7148
7149         * ../errors/cs0215.cs : Added.
7150
7151         * ../errors/cs0556.cs : Added.
7152
7153         * ../errors/cs0555.cs : Added.
7154
7155 2001-10-01  Miguel de Icaza  <miguel@ximian.com>
7156
7157         * cs-tokenizer.cs: Reimplemented Location to be a struct with a
7158         single integer which is really efficient
7159
7160 2001-10-01  Ravi Pratap  <ravi@ximian.com>
7161
7162         *  expression.cs (Expression::ImplicitUserConversion): Use location
7163         even in the case when we are examining True operators.
7164
7165         * class.cs (Operator::Define): Perform extensive checks to conform
7166         with the rules for operator overloading in the spec.
7167
7168         * expression.cs (Expression::ImplicitReferenceConversion): Implement
7169         some of the other conversions mentioned in the spec.
7170
7171         * typemanager.cs (array_type): New static member for the System.Array built-in
7172         type.
7173
7174         (cloneable_interface): For System.ICloneable interface.
7175
7176         * driver.cs (Driver::Driver): Initialize TypeManager's core types even before
7177         we start resolving the tree and populating types.
7178
7179         * ../errors/errors.txt : Update for error numbers -7, -8, -9, -10
7180
7181 2001-10-01  Miguel de Icaza  <miguel@ximian.com>
7182
7183         * expression.cs (Expression::ExprClassFromMemberInfo,
7184         Expression::Literalize): Create literal expressions from
7185         FieldInfos which are literals.
7186
7187         (ConvertNumericExplicit, ImplicitNumericConversion): Fix a few
7188         type casts, because they were wrong.  The test suite in tests
7189         caught these ones.
7190
7191         (ImplicitNumericConversion): ushort to ulong requires a widening
7192         cast.
7193
7194         Int32 constant to long requires widening cast as well.
7195
7196         * literal.cs (LongLiteral::EmitLong): Do not generate i4 constants
7197         for integers because the type on the stack is not i4.
7198
7199 2001-09-30  Miguel de Icaza  <miguel@ximian.com>
7200
7201         * expression.cs (report118): require location argument.
7202
7203         * parameter.cs: Do not dereference potential null value.
7204
7205         * class.cs: Catch methods that lack the `new' keyword when
7206         overriding a name.  Report warnings when `new' is used without
7207         anything being there to override.
7208
7209         * modifiers.cs: Handle `NEW' as MethodAttributes.NewSlot.
7210
7211         * class.cs: Only add constructor to hashtable if it is non-null
7212         (as now constructors can fail on define).
7213
7214         (TypeManager, Class, Struct): Take location arguments.
7215
7216         Catch field instance initialization in structs as errors.
7217
7218         accepting_filter: a new filter for FindMembers that is static so
7219         that we dont create an instance per invocation.
7220
7221         (Constructor::Define): Catch errors where a struct constructor is
7222         parameterless
7223
7224         * cs-parser.jay: Pass location information for various new
7225         constructs.
7226
7227         * delegate.cs (Delegate): take a location argument.
7228
7229         * driver.cs: Do not call EmitCode if there were problesm in the
7230         Definition of the types, as many Builders wont be there.
7231
7232         * decl.cs (Decl::Decl): Require a location argument.
7233
7234         * cs-tokenizer.cs: Handle properly hex constants that can not fit
7235         into integers, and find the most appropiate integer for it.
7236
7237         * literal.cs: Implement ULongLiteral.
7238
7239         * rootcontext.cs: Provide better information about the location of
7240         failure when CreateType fails.
7241
7242 2001-09-29  Miguel de Icaza  <miguel@ximian.com>
7243
7244         * rootcontext.cs (RootContext::PopulateTypes): Populates structs
7245         as well.
7246
7247         * expression.cs (Binary::CheckShiftArguments): Add missing type
7248         computation.
7249         (Binary::ResolveOperator): Add type to the logical and and logical
7250         or, Bitwise And/Or and Exclusive Or code paths, it was missing
7251         before.
7252
7253         (Binary::DoNumericPromotions): In the case where either argument
7254         is ulong (and most signed types combined with ulong cause an
7255         error) perform implicit integer constant conversions as well.
7256
7257 2001-09-28  Miguel de Icaza  <miguel@ximian.com>
7258
7259         * expression.cs (UserImplicitCast): Method should always be
7260         non-null.
7261         (Invocation::BetterConversion): Simplified test for IntLiteral.
7262
7263         (Expression::ImplicitNumericConversion): Split this routine out.
7264         Put the code that performs implicit constant integer conversions
7265         here.
7266
7267         (Expression::Resolve): Become a wrapper around DoResolve so we can
7268         check eclass and type being set after resolve.
7269
7270         (Invocation::Badness): Remove this dead function
7271
7272         (Binary::ResolveOperator): Do not compute the expensive argumnets
7273         unless we have a union for it.
7274
7275         (Probe::Emit): Is needs to do an isinst and then
7276         compare against null.
7277
7278         (::CanConvert): Added Location argument.  If the Location argument
7279         is null (Location.Null), then we do not report errors.  This is
7280         used by the `probe' mechanism of the Explicit conversion.  We do
7281         not want to generate an error for something that the user
7282         explicitly requested to be casted.  But the pipeline for an
7283         explicit cast first tests for potential implicit casts.
7284
7285         So for now, if the Location is null, it means `Probe only' to
7286         avoid adding another argument.   Might have to revise this
7287         strategy later.
7288
7289         (ClassCast): New class used to type cast objects into arbitrary
7290         classes (used in Explicit Reference Conversions).
7291
7292         Implement `as' as well.
7293
7294         Reverted all the patches from Ravi below: they were broken:
7295
7296                 * The use of `level' as a mechanism to stop recursive
7297                   invocations is wrong.  That was there just to catch the
7298                   bug with a strack trace but not as a way of addressing
7299                   the problem.
7300
7301                   To fix the problem we have to *understand* what is going
7302                   on and the interactions and come up with a plan, not
7303                   just get things going.
7304
7305                 * The use of the type conversion cache that I proposed
7306                   last night had an open topic: How does this work across
7307                   protection domains.  A user defined conversion might not
7308                   be public in the location where we are applying the
7309                   conversion, a different conversion might be selected
7310                   (ie, private A->B (better) but public B->A (worse),
7311                   inside A, A->B applies, but outside it, B->A will
7312                   apply).
7313
7314                 * On top of that (ie, even if the above is solved),
7315                   conversions in a cache need to be abstract.  Ie, `To
7316                   convert from an Int to a Short use an OpcodeCast', not
7317                   `To convert from an Int to a Short use the OpcodeCast on
7318                   the variable 5' (which is what this patch was doing).
7319
7320 2001-09-28  Ravi Pratap  <ravi@ximian.com>
7321
7322         * expression.cs (Invocation::ConversionExists): Re-write to use
7323         the conversion cache
7324
7325         (Expression::ConvertImplicit): Automatic bailing out if level != 0. Also
7326         cache all conversions done, not just user-defined ones.
7327
7328         (Invocation::BetterConversion): The real culprit. Use ConversionExists
7329         to determine if a conversion exists instead of acutually trying to
7330         perform the conversion. It's faster too.
7331
7332         (Expression::ConvertExplicit): Modify to use ConversionExists to check
7333         and only then attempt the implicit conversion.
7334
7335 2001-09-28  Ravi Pratap  <ravi@ximian.com>
7336
7337         * expression.cs (ConvertImplicit): Use a cache for conversions
7338         already found. Check level of recursion and bail out if necessary.
7339
7340 2001-09-28  Miguel de Icaza  <miguel@ximian.com>
7341
7342         * typemanager.cs (string_concat_string_string, string_concat_object_object):
7343         Export standard methods that we expect for string operations.
7344
7345         * statement.cs (Block::UsageWarning): Track usage of variables and
7346         report the errors for not used variables.
7347
7348         * expression.cs (Conditional::Resolve, ::Emit): Implement ?:
7349         operator.
7350
7351 2001-09-27  Miguel de Icaza  <miguel@ximian.com>
7352
7353         * codegen.cs: remove unnneded code
7354
7355         * expression.cs: Removed BuiltinTypeAccess class
7356
7357         Fix the order in which implicit conversions are
7358         done.
7359
7360         The previous fixed dropped support for boxed conversions (adding a
7361         test to the test suite now)
7362
7363         (UserImplicitCast::CanConvert): Remove test for source being null,
7364         that code is broken.  We should not feed a null to begin with, if
7365         we do, then we should track the bug where the problem originates
7366         and not try to cover it up here.
7367
7368         Return a resolved expression of type UserImplicitCast on success
7369         rather than true/false.  Ravi: this is what I was talking about,
7370         the pattern is to use a static method as a "constructor" for
7371         objects.
7372
7373         Also, do not create arguments until the very last minute,
7374         otherwise we always create the arguments even for lookups that
7375         will never be performed.
7376
7377         (UserImplicitCast::Resolve): Eliminate, objects of type
7378         UserImplicitCast are born in a fully resolved state.
7379
7380         * typemanager.cs (InitCoreTypes): Init also value_type
7381         (System.ValueType).
7382
7383         * expression.cs (Cast::Resolve): First resolve the child expression.
7384
7385         (LValue): Add new method AddressOf to be used by
7386         the `&' operator.
7387
7388         Change the argument of Store to take an EmitContext instead of an
7389         ILGenerator, because things like FieldExpr need to be able to call
7390         their children expression to generate the instance code.
7391
7392         (Expression::Error, Expression::Warning): Sugar functions for
7393         reporting errors.
7394
7395         (Expression::MemberLookup): Accept a TypeContainer instead of a
7396         Report as the first argument.
7397
7398         (Expression::ResolvePrimary): Killed.  I still want to improve
7399         this as currently the code is just not right.
7400
7401         (Expression::ResolveMemberAccess): Simplify, but it is still
7402         wrong.
7403
7404         (Unary::Resolve): Catch errors in AddressOf operators.
7405
7406         (LocalVariableReference::Emit, ::Store, ::AddressOf): typecast
7407         index to a byte for the short-version, or the compiler will choose
7408         the wrong Emit call, which generates the wrong data.
7409
7410         (ParameterReference::Emit, ::Store): same.
7411
7412         (FieldExpr::AddressOf): Implement.
7413
7414         * typemanager.cs: TypeManager: made public variable instead of
7415         property.
7416
7417         * driver.cs: document --fatal.
7418
7419         * report.cs (ErrorMessage, WarningMessage): new names for the old
7420         Error and Warning classes.
7421
7422         * cs-parser.jay (member_access): Turn built-in access to types
7423         into a normal simplename
7424
7425 2001-09-27  Ravi Pratap  <ravi@ximian.com>
7426
7427         * expression.cs (Invocation::BetterConversion): Fix to cope
7428         with q being null, since this was introducing a bug.
7429
7430         * expression.cs (ConvertImplicit): Do built-in conversions first.
7431
7432 2001-09-27  Ravi Pratap  <ravi@ximian.com>
7433
7434         * expression.cs (UserImplicitCast::Resolve): Fix bug.
7435
7436 2001-09-27  Ravi Pratap  <ravi@ximian.com>
7437
7438         * class.cs (TypeContainer::AddConstructor): Fix a stupid bug
7439         I had introduced long ago (what's new ?).
7440
7441         * expression.cs (UserImplicitCast::CanConvert): Static method to do
7442         the work of all the checking.
7443         (ConvertImplicit): Call CanConvert and only then create object if necessary.
7444         (UserImplicitCast::CanConvert, ::Resolve): Re-write.
7445
7446         (Unary::Operator): Rename Add and Subtract to Addition and Subtraction because
7447         that is the right way.
7448
7449         (Invocation::MakeUnionSet): Convenience function to make unions of sets for
7450         overloading resolution. Use everywhere instead of cutting and pasting code.
7451
7452         (Binary::ResolveOperator): Use MakeUnionSet.
7453
7454         (UserImplicitCast::CanConvert, ::Resolve): Update to take care of the case when
7455         we have to convert to bool types. Not complete yet.
7456
7457 2001-09-27  Miguel de Icaza  <miguel@ximian.com>
7458
7459         * typemanager.cs (TypeManager::CSharpName): support ushort.
7460
7461         * expression.cs (Expression::TryImplicitIntConversion): Attempts
7462         to provide an expression that performsn an implicit constant int
7463         conversion (section 6.1.6).
7464         (Expression::ConvertImplicitRequired): Reworked to include
7465         implicit constant expression conversions.
7466
7467         (Expression::ConvertNumericExplicit): Finished.
7468
7469         (Invocation::Emit): If InstanceExpression is null, then it means
7470         that we perform a call on this.
7471
7472 2001-09-26  Miguel de Icaza  <miguel@ximian.com>
7473
7474         * expression.cs (Unary::Emit): Remove some dead code.
7475         (Probe): Implement Resolve and Emit for `is'.
7476         (Expression::ConvertImplicitRequired): Attempt to do constant
7477         expression conversions here.  Maybe should be moved to
7478         ConvertImplicit, but I am not sure.
7479         (Expression::ImplicitLongConstantConversionPossible,
7480         Expression::ImplicitIntConstantConversionPossible): New functions
7481         that tell whether is it possible to apply an implicit constant
7482         expression conversion.
7483
7484         (ConvertNumericExplicit): Started work on explicit numeric
7485         conversions.
7486
7487         * cs-parser.jay: Update operator constants.
7488
7489         * parameter.cs (Parameters::GetParameterInfo): Hook up VerifyArgs
7490         (Parameters::GetSignature): Hook up VerifyArgs here.
7491         (Parameters::VerifyArgs): Verifies that no two arguments have the
7492         same name.
7493
7494         * class.cs (Operator): Update the operator names to reflect the
7495         ones that the spec expects (as we are just stringizing the
7496         operator names).
7497
7498         * expression.cs (Unary::ResolveOperator): Fix bug: Use
7499         MethodInfo's ReturnType instead of LookupMethodByBuilder as the
7500         previous usage did only work for our methods.
7501         (Expression::ConvertImplicit): Handle decimal implicit numeric
7502         conversions as well.
7503         (Expression::InternalTypeConstructor): Used to invoke constructors
7504         on internal types for default promotions.
7505
7506         (Unary::Emit): Implement special handling for the pre/post
7507         increment/decrement for overloaded operators, as they need to have
7508         the same semantics as the other operators.
7509
7510         (Binary::ResolveOperator): ditto.
7511         (Invocation::ConversionExists): ditto.
7512         (UserImplicitCast::Resolve): ditto.
7513
7514 2001-09-26  Ravi Pratap  <ravi@ximian.com>
7515
7516         * expression.cs (Unary::Emit and Binary::Emit): If we have an overloaded
7517         operator, return after emitting body. Regression tests pass again !
7518
7519         * expression.cs (ConvertImplicit): Take TypeContainer as first argument
7520         (Unary::ForceConversion, Binary::ForceConversion): Ditto.
7521         (Invocation::OverloadResolve): Ditto.
7522         (Invocation::BetterFunction, BetterConversion, ConversionExists): Ditto.
7523
7524         * everywhere : update calls to the above methods accordingly.
7525
7526 2001-09-26  Miguel de Icaza  <miguel@ximian.com>
7527
7528         * assign.cs (Assign): Make it inherit from ExpressionStatement.
7529
7530         * expression.cs (ExpressionStatement): New base class used for
7531         expressions that can appear in statements, so that we can provide
7532         an alternate path to generate expression that do not leave a value
7533         on the stack.
7534
7535         (Expression::Emit, and all the derivatives): We no longer return
7536         whether a value is left on the stack or not.  Every expression
7537         after being emitted leaves a single value on the stack.
7538
7539         * codegen.cs (EmitContext::EmitStatementExpression): Use the
7540         facilties of ExpressionStatement if possible.
7541
7542         * cs-parser.jay: Update statement_expression.
7543
7544 2001-09-25  Miguel de Icaza  <miguel@ximian.com>
7545
7546         * driver.cs: Change the wording of message
7547
7548 2001-09-25  Ravi Pratap  <ravi@ximian.com>
7549
7550         * expression.cs (Binary::ResolveOperator): Had forgottten to set
7551         the type of the expression to the return type of the method if
7552         we have an overloaded operator match ! The regression tests pass again !
7553         (Unary::ResolveOperator): Ditto.
7554
7555         * expression.cs (Invocation::ConversionExists): Correct the member lookup
7556         to find "op_Implicit", not "implicit" ;-)
7557         (UserImplicitCast): New class to take care of user-defined implicit conversions.
7558         (ConvertImplicit, ForceConversion): Take TypeContainer argument
7559
7560         * everywhere : Correct calls to the above accordingly.
7561
7562         * expression.cs (UserImplicitCast::Resolve, ::Emit): Implement.
7563         (ConvertImplicit): Do user-defined conversion if it exists.
7564
7565 2001-09-24  Miguel de Icaza  <miguel@ximian.com>
7566
7567         * assign.cs: track location.
7568         (Resolve): Use implicit conversions on assignment.
7569
7570         * literal.cs: Oops.  Not good, Emit of short access values should
7571         pass (Bytes) or the wrong argument will be selected.
7572
7573         * expression.cs (Unary::Emit): Emit code for -expr.
7574
7575         (Unary::ResolveOperator): Handle `Substract' for non-constants
7576         (substract from zero from the non-constants).
7577         Deal with Doubles as well.
7578
7579         (Expression::ConvertImplicitRequired): New routine that reports an
7580         error if no implicit conversion exists.
7581
7582         (Invocation::OverloadResolve): Store the converted implicit
7583         expressions if we make them
7584
7585 2001-09-24  Ravi Pratap  <ravi@ximian.com>
7586
7587         * class.cs (ConstructorInitializer): Take a Location argument.
7588         (ConstructorBaseInitializer): Same here.
7589         (ConstructorThisInitializer): Same here.
7590
7591         * cs-parser.jay : Update all calls accordingly.
7592
7593         * expression.cs (Unary, Binary, New): Take location argument.
7594         Update accordingly everywhere.
7595
7596         * cs-parser.jay : Update all calls to the above to take a location
7597         argument.
7598
7599         * class.cs : Ditto.
7600
7601 2001-09-24  Ravi Pratap  <ravi@ximian.com>
7602
7603         * expression.cs (Invocation::BetterFunction): Take TypeContainer argument
7604         (Invocation::BetterConversion): Same here
7605         (Invocation::ConversionExists): Ditto.
7606
7607         (Invocation::ConversionExists): Implement.
7608
7609 2001-09-22  Ravi Pratap  <ravi@ximian.com>
7610
7611         * expression.cs (OverloadResolve): Improve some more to catch errors 1502 and 1503
7612         Also take an additional TypeContainer argument.
7613
7614         * All over : Pass in TypeContainer as argument to OverloadResolve.
7615
7616         * typemanager.cs (CSharpName): Update to check for the string type and return
7617         that too.
7618
7619         * expression.cs (Invocation::FullMethodDesc): New static method to return a string fully describing
7620         a given method.
7621
7622 2001-09-21  Ravi Pratap  <ravi@ximian.com>
7623
7624         * expression.cs (Invocation::OverloadResolve): Re-write to conform more to the spec.
7625         (Invocation::BetterFunction): Implement.
7626         (Invocation::BetterConversion): Implement.
7627         (Invocation::ConversionExists): Skeleton, no implementation yet.
7628
7629         Okay, things work fine !
7630
7631 2001-09-21  Miguel de Icaza  <miguel@ximian.com>
7632
7633         * typemanager.cs: declare and load enum_type, delegate_type and
7634         void_type.
7635
7636         * expression.cs (Expression::Emit): Now emit returns a value that
7637         tells whether a value is left on the stack or not.  This strategy
7638         might be reveted tomorrow with a mechanism that would address
7639         multiple assignments.
7640         (Expression::report118): Utility routine to report mismatches on
7641         the ExprClass.
7642
7643         (Unary::Report23): Report impossible type/operator combination
7644         utility function.
7645
7646         (Unary::IsIncrementableNumber): Whether the type can be
7647         incremented or decremented with add.
7648         (Unary::ResolveOperator): Also allow enumerations to be bitwise
7649         complemented.
7650         (Unary::ResolveOperator): Implement ++, !, ~,
7651
7652         (Invocation::Emit): Deal with new Emit convetion.
7653
7654         * All Expression derivatives: Updated their Emit method to return
7655         whether they leave values on the stack or not.
7656
7657         * codegen.cs (CodeGen::EmitStatement): Pop values left on the
7658         stack for expressions that are statements.
7659
7660 2001-09-20  Miguel de Icaza  <miguel@ximian.com>
7661
7662         * expression.cs (LValue): New interface.  Must be implemented by
7663         LValue objects.
7664         (LocalVariableReference, ParameterReference, FieldExpr): Implement
7665         LValue interface.
7666
7667         * assign.cs (Assign::Emit, Assign::Resolve): Use new LValue
7668         interface for generating code, simplifies the code.
7669
7670 2001-09-20  Ravi Pratap  <ravi@ximian.com>
7671
7672         * expression.cs (everywhere): Comment out return statements in ::Resolve
7673         methods to avoid the warnings.
7674
7675 2001-09-20  Miguel de Icaza  <miguel@ximian.com>
7676
7677         * driver.cs (parse): Report error 2001 if we can not open the
7678         source file.
7679
7680         * expression.cs (SimpleName::ResolveSimpleName): Error if we can
7681         not resolve it.
7682
7683         * cs-parser.jay (QualifierIdentifier): Pass location to SimpleName
7684         object.
7685
7686         * statement.cs (Block::EmitMeta): Reuse the count across all the variables,
7687         otherwise nested blocks end up with the same index.
7688
7689         * codegen.cs (CodeGen::EmitTopBlock): Pass initial sequence
7690
7691         * expression.cs:  Instead of having FIXMEs in the Resolve
7692         functions, throw exceptions so it is obvious that we are facing a
7693         bug.
7694
7695         * cs-parser.jay (invocation_expression): Pass Location information.
7696
7697         * codegen.cs (CodeGen::Save, CodeGen::CodeGen, CodeGen::Basename):
7698         Use a basename for those routines because .NET does not like paths
7699         on them.
7700
7701         * class.cs (TypeContainer::AddMethod): Do not call DefineName if the name was
7702         already defined.
7703
7704 2001-09-19  Miguel de Icaza  <miguel@ximian.com>
7705
7706         * typemanager.cs (TypeManager::CoreLookupType): A function to make sure that we
7707         are loading the correct data types (throws an exception if not).
7708         (TypeManager::InitCoreTypes): Use CoreLookupType
7709
7710         * expression.cs (Unary::ResolveOperator): return the child
7711         expression for expressions which are just +expr.
7712         (Unary::ResolveOperator): Return negative literals for -LITERAL
7713         expressions (otherwise they are Unary {Literal}).
7714         (Invocation::Badness): Take into account `Implicit constant
7715         expression conversions'.
7716
7717         * literal.cs (LongLiteral): Implement long literal class.
7718         (IntLiteral): export the `Value' of the intliteral.
7719
7720 2001-09-19  Ravi Pratap  <ravi@ximian.com>
7721
7722         * expression.cs (Binary::Emit): Finally get the emission right ! Woo!
7723
7724         * class.cs (Operator::Define): Change the methodname prefix to 'op_'
7725         instead of 'Operator'
7726
7727         * expression.cs (Binary::ResolveOperator): Update accordingly.
7728         (Unary::Operator): Change names to 'Add' and 'Subtract' instead 'Plus'
7729         and 'Minus'
7730
7731         * cs-parser.jay (unary_expression): Update to use the new names.
7732
7733         * gen-treedump.cs (GetUnary): Same here.
7734
7735         * expression.cs (Unary::Resolve): Implement.
7736         (Binary::ResolveOperator): Re-write bits to quietly continue if no overloaded
7737         operators are found instead of making noise ;-)
7738         (Unary::ResolveOperator): New method to do precisely the same thing which
7739         Binary::ResolveOperator does for Binary expressions.
7740         (Unary.method, .Arguments): Add.
7741         (Unary::OperName): Implement.
7742         (Unary::ForceConversion): Copy and Paste !
7743
7744         * class.cs (Operator::Define): Fix a small bug for the case when we have
7745         a unary operator.
7746
7747         * expression.cs (Unary::Emit): Implement. Need to find the right Opcodes
7748         for the inbuilt operators. Only overloading works for now ;-)
7749
7750 2001-09-18  Miguel de Icaza  <miguel@ximian.com>
7751
7752         * expression.cs (CheckedExpr::Resolve, CheckedExpr::Emit,
7753         UnCheckedExpr::Resolve, UnCheckedExpr::Emit): Implement.
7754
7755         * expression.cs (This::Emit): Implement.
7756         (This::Resolve): Implement.
7757         (TypeOf:Resolve): Implement.
7758         (Expression::ResolveSimpleName): Add an implicit this to instance
7759         field references.
7760         (MemberAccess::Resolve): Deal with Parameters and Fields.
7761         Bind instance variable to Field expressions.
7762         (FieldExpr::Instance): New field used to track the expression that
7763         represents the object instance.
7764         (FieldExpr::Resolve): Track potential errors from MemberLookup not
7765         binding
7766         (FieldExpr::Emit): Implement.
7767
7768         * codegen.cs (EmitIf, EmitStatement, EmitBlock): Propagate whether
7769         the last instruction contains a return opcode to avoid generating
7770         the last `ret' instruction (this generates correct code, and it is
7771         nice to pass the peverify output).
7772
7773         * class.cs (TypeContainer::EmitFieldInitializers): Implement field
7774         initializer for static and instance variables.
7775         (Constructor::Emit): Allow initializer to be null in the case of
7776         static constructors.  Only emit initializer for instance
7777         constructors.
7778
7779         (TypeContainer::FindMembers): Return a null array if there are no
7780         matches.
7781
7782         Also fix the code for the MemberTypes.Method branch, as it was not
7783         scanning that for operators (or tried to access null variables before).
7784
7785         * assign.cs (Assign::Emit): Handle instance and static fields.
7786
7787         * TODO: Updated.
7788
7789         * driver.cs: Stop compilation if there are parse errors.
7790
7791         * cs-parser.jay (constructor_declaration): Provide default base
7792         initializer for non-static constructors.
7793         (constructor_declarator): Do not provide a default base
7794         initializers if none was specified.
7795         Catch the fact that constructors should not have parameters.
7796
7797         * class.cs: Do not emit parent class initializers for static
7798         constructors, that should be flagged as an error.
7799
7800 2001-09-18  Ravi Pratap  <ravi@ximian.com>
7801
7802         * class.cs (RegisterMethodBuilder): Remove : it's unnecessary.
7803         Move back code into TypeContainer::Populate.
7804
7805 2001-09-18  Ravi Pratap  <ravi@ximian.com>
7806
7807         * class.cs (TypeContainer::AddConstructor): Fix the check to
7808         compare against Name, not Basename.
7809         (Operator::OpType): Change Plus and Minus to Add and Subtract.
7810
7811         * cs-parser.jay : Update accordingly.
7812
7813         * class.cs (TypeContainer::FindMembers): For the case where we are searching
7814         for methods, don't forget to look into the operators too.
7815         (RegisterMethodBuilder): Helper method to take care of this for
7816         methods, constructors and operators.
7817         (Operator::Define): Completely revamp.
7818         (Operator.OperatorMethod, MethodName): New fields.
7819         (TypeContainer::Populate): Move the registering of builders into
7820         RegisterMethodBuilder.
7821         (Operator::Emit): Re-write.
7822
7823         * expression.cs (Binary::Emit): Comment out code path to emit method
7824         invocation stuff for the case when we have a user defined operator. I am
7825         just not able to get it right !
7826
7827 2001-09-17  Miguel de Icaza  <miguel@ximian.com>
7828
7829         * expression.cs (Expression::OverloadResolve): Drop TypeContainer
7830         argument.
7831
7832         (Expression::MemberLookup): Provide a version that allows to
7833         specify the MemberTypes and BindingFlags.
7834
7835         * statement.cs (Block::GetVariableInfo): Forgot to recurse here,
7836         so it was not fetching variable information from outer blocks.
7837
7838         * modifiers.cs: (Modifiers::TypeAttr): Invert condition on
7839         Beforefieldinit as it was buggy.
7840
7841         * rootcontext.cs (::LookupInterfaceOrClass): Removed an Error -200
7842         that Ravi put here.
7843
7844         * class.cs (Constructor::Emit): Only emit if block is not null.
7845         (TypeContainer::EmitDefaultConstructor): Removed routine, now we
7846         deal with this by semantically definining it as if the user had
7847         done it.
7848
7849         (TypeContainer::FindMembers): Removed ad-hoc hack to deal with
7850         constructors as we now "emit" them at a higher level.
7851
7852         (TypeContainer::DefineDefaultConstructor): Used to define the
7853         default constructors if none was provided.
7854
7855         (ConstructorInitializer): Add methods Resolve and Emit.
7856
7857         * expression.cs: Cast to ConstructorInfo instead of MethodInfo
7858
7859 2001-09-17  Ravi Pratap  <ravi@ximian.com>
7860
7861         * class.cs (TypeContainer::EmitDefaultConstructor): Register
7862         the default constructor builder with our hashtable for methodbuilders
7863         to methodcores.
7864
7865         * expression.cs (Invocation::OverloadResolve): Add a check for pd == null
7866         and argument_count is 0 in which case we have a match.
7867         (Binary::ResolveOperator): More null checking and miscellaneous coding
7868         style cleanup.
7869
7870 2001-09-17  Ravi Pratap  <ravi@ximian.com>
7871
7872         * rootcontext.cs (IsNameSpace): Compare against null.
7873
7874         * everywhere : Correct spelling to 'Greater' and to 'Subtract'
7875
7876         * class.cs (Operator::OpType): Change names to match the ones in Binary::Operator
7877         and Unary::Operator.
7878
7879         * cs-parser.jay (operator_declaration, CheckBinaryOperator, CheckUnaryOperator): Update
7880         accordingly.
7881
7882         * expression.cs (Binary::method): New member to hold the MethodBase for the case when
7883         we have overloaded operators.
7884         (Binary::ResolveOperator): Implement the part which does the operator overload
7885         resolution.
7886
7887         * class.cs (Operator::Emit): Implement.
7888         (TypeContainer::Emit): Emit the operators we have too.
7889
7890         * expression.cs (Binary::Emit): Update to emit the appropriate code for
7891         the case when we have a user-defined operator.
7892
7893 2001-09-17  Miguel de Icaza  <miguel@ximian.com>
7894
7895         * rootcontext.cs: Fix bug: tree.Namespaces might be null.
7896
7897 2001-09-16  Ravi Pratap  <ravi@ximian.com>
7898
7899         * class.cs (EmitStaticFieldInitializers, EmitFieldInitializers): Make public.
7900         (TypeContainer::EmitConstructor): Remove and move code into Contructor::Emit.
7901         (Constructor::Emit): Implement.
7902         (EmitStaticFieldInitializers, EmitFieldInitializers): Ensure we return immediately
7903         if we have no work to do.
7904         (TypeContainer::Emit): Pass in TypeContainer as argument to the constructor's
7905         Emit method.
7906
7907         * interface.cs (Interface::InterfaceAttr): Re-write to be more correct and complete.
7908         (Interface::IsTopLevel): Add. Same as TypeContainer::IsTopLevel.
7909
7910         * class.cs (TypeContainer::IsTopLevel): Modify to use parent.Parent instead
7911         of parent.parent.
7912
7913 2001-09-15  Ravi Pratap  <ravi@ximian.com>
7914
7915         * tree.cs (Tree::namespaces): New hashtable to keep track of namespaces
7916         in the source.
7917         (Tree::RecordNamespace): Method to do what the name says ;-)
7918         (Tree::Namespaces): Property to get at the namespaces hashtable.
7919
7920         * cs-parser.jay (namespace_declaration): Call RecordNamespace to
7921         keep track.
7922
7923         * rootcontext.cs (IsNamespace): Fixed it :-)
7924
7925 2001-09-14  Miguel de Icaza  <miguel@ximian.com>
7926
7927         * class.cs (TypeContainer::FindMembers): Add support for
7928         constructors.
7929         (MethodCore): New class that encapsulates both the shared aspects
7930         of a Constructor and a Method.
7931         (Method, Constructor): Factored pieces into MethodCore.
7932
7933         * driver.cs: Added --fatal which makes errors throw exceptions.
7934         Load System assembly as well as part of the standard library.
7935
7936         * report.cs: Allow throwing exceptions on errors for debugging.
7937
7938         * modifiers.cs: Do not use `parent', instead use the real type
7939         container to evaluate permission settings.
7940
7941         * class.cs: Put Ravi's patch back in.  He is right, and we will
7942         have to cope with the
7943
7944 2001-09-14  Ravi Pratap  <ravi@ximian.com>
7945
7946         * modifiers.cs (TypeAttr, MethodAttr, FieldAttr): Map protected internal to
7947         FamORAssem, not FamANDAssem.
7948
7949 2001-09-14  Miguel de Icaza  <miguel@ximian.com>
7950
7951         * driver.cs: Added --parse option that only parses its input files
7952         and terminates.
7953
7954         * class.cs: Reverted last change from Ravi to IsTopLevel.  That is
7955         incorrect.  IsTopLevel is not used to tell whether an object is
7956         root_types or not (that can be achieved by testing this ==
7957         root_types).  But to see if this is a top-level *class* (not
7958         necessarly our "toplevel" container).
7959
7960 2001-09-14  Ravi Pratap  <ravi@ximian.com>
7961
7962         * enum.cs (Enum::Define): Modify to call the Lookup method on the
7963         parent instead of a direct call to GetType.
7964
7965 2001-09-14  Ravi Pratap  <ravi@ximian.com>
7966
7967         * class.cs (TypeContainer::TypeAttr): Remove property code and move it into
7968         Modifiers.TypeAttr. This should just be a call to that method.
7969
7970         * modifiers.cs (TypeAttr): Re-write and take an extra argument, the TypeContainer
7971         object so that we can determine if we are top-level or not.
7972
7973         * delegate.cs (Delegate::Define): Update call to TypeAttr method to pass in the
7974         TypeContainer too.
7975
7976         * enum.cs (Enum::Define): Ditto.
7977
7978         * modifiers.cs (FieldAttr): Re-write.
7979
7980         * class.cs (TypeContainer::IsTopLevel): Change accessibility to public.
7981         (TypeContainer::HaveStaticConstructor): New property to provide access
7982         to precisely that info.
7983
7984         * modifiers.cs (MethodAttr): Re-write.
7985         (EventAttr): Remove altogether as there seems to be no ostensible use for it.
7986
7987         * class.cs (TypeContainer::IsTopLevel): Re-write. root_types doesn't seem to be the parent
7988         of top-level types as claimed.
7989
7990 2001-09-13  Miguel de Icaza  <miguel@ximian.com>
7991
7992         * expression.cs (MemberLookup): Fruitless attempt to lookup
7993         constructors.  Maybe I need to emit default constructors?  That
7994         might be it (currently .NET emits this for me automatically).
7995         (Invocation::OverloadResolve): Cope with Arguments == null.
7996         (Invocation::EmitArguments): new function, shared by the new
7997         constructor and us.
7998         (Invocation::Emit): Handle static and instance methods.  Emit
7999         proper call instruction for virtual or non-virtual invocations.
8000         (New::Emit): Implement.
8001         (New::Resolve): Implement.
8002         (MemberAccess:Resolve): Implement.
8003         (MethodGroupExpr::InstanceExpression): used conforming to the spec
8004         to track instances.
8005         (FieldExpr::Resolve): Set type.
8006
8007         * support.cs: Handle empty arguments.
8008
8009         * cs-parser.jay (CompositeLookup, QualifierIdentifier,
8010         SimpleLookup): Auxiliary routines to help parse a qualifier
8011         identifier.
8012
8013         Update qualifier_identifier rule.
8014
8015         * codegen.cs: Removed debugging messages.
8016
8017         * class.cs: Make this a global thing, this acts just as a "key" to
8018         objects that we might have around.
8019
8020         (Populate): Only initialize method_builders_to_methods once.
8021
8022         * expression.cs (PropertyExpr): Initialize type from the
8023         PropertyType.
8024
8025         * codegen.cs (EmitContext::EmitBoolExpression): Use propper
8026         Resolve pattern.  Attempt to implicitly convert value to boolean.
8027         Emit code.
8028
8029         * expression.cs: Set the type for the int32/int32 argument case.
8030         (Binary::ResolveOperator): Set the return type to boolean for
8031         comparission operators
8032
8033         * typemanager.cs: Remove debugging print code.
8034
8035         (Invocation::Resolve): resolve type.
8036
8037         * class.cs: Allocate a MemberInfo of the correct size, as the code
8038         elsewhere depends on the test to reflect the correct contents.
8039
8040         (Method::) Keep track of parameters, due to System.Reflection holes
8041
8042         (TypeContainer::Populate): Keep track of MethodBuilders to Method
8043         mapping here.
8044
8045         (TypeContainer::FindMembers): Use ArrayList and then copy an array
8046         of the exact size and return that.
8047
8048         (Class::LookupMethodByBuilder): New function that maps
8049         MethodBuilders to its methods.  Required to locate the information
8050         on methods because System.Reflection bit us again.
8051
8052         * support.cs: New file, contains an interface ParameterData and
8053         two implementations: ReflectionParameters and InternalParameters
8054         used to access Parameter information.  We will need to grow this
8055         as required.
8056
8057         * expression.cs (Invocation::GetParameterData): implement a cache
8058         and a wrapper around the ParameterData creation for methods.
8059         (Invocation::OverloadResolve): Use new code.
8060
8061 2001-09-13  Ravi Pratap  <ravi@ximian.com>
8062
8063         * class.cs (TypeContainer::EmitField): Remove and move into
8064         (Field::Define): here and modify accordingly.
8065         (Field.FieldBuilder): New member.
8066         (TypeContainer::Populate): Update accordingly.
8067         (TypeContainer::FindMembers): Implement.
8068
8069 2001-09-13  Miguel de Icaza  <miguel@ximian.com>
8070
8071         * statement.cs: (VariableInfo::VariableType): New field to be
8072         initialized with the full type once it is resolved.
8073
8074 2001-09-12  Miguel de Icaza  <miguel@ximian.com>
8075
8076         * parameter.cs (GetParameterInfo): Use a type cache to compute
8077         things only once, and to reuse this information
8078
8079         * expression.cs (LocalVariableReference::Emit): Implement.
8080         (OpcodeCast::Emit): fix.
8081
8082         (ParameterReference::Resolve): Implement.
8083         (ParameterReference::Emit): Implement.
8084
8085         * cs-parser.jay: Fix bug introduced by Ravi, variable initializers
8086         that are expressions need to stay as Expressions.
8087
8088         * typemanager.cs (CSharpName): Returns the C# name of a type if
8089         possible.
8090
8091         * expression.cs (Expression::ConvertImplicit): New function that
8092         implements implicit type conversions.
8093
8094         (Expression::ImplicitReferenceConversion): Implements implicit
8095         reference conversions.
8096
8097         (EmptyCast): New type for transparent casts.
8098
8099         (OpcodeCast): New type for casts of types that are performed with
8100         a sequence of bytecodes.
8101
8102         (BoxedCast): New type used for casting value types into reference
8103         types.  Emits a box opcode.
8104
8105         (Binary::DoNumericPromotions): Implements numeric promotions of
8106         and computation of the Binary::Type.
8107
8108         (Binary::EmitBranchable): Optimization.
8109
8110         (Binary::Emit): Implement code emission for expressions.
8111
8112         * typemanager.cs (TypeManager): Added two new core types: sbyte
8113         and byte.
8114
8115 2001-09-12  Ravi Pratap  <ravi@ximian.com>
8116
8117         * class.cs (TypeContainer::FindMembers): Method which does exactly
8118         what Type.FindMembers does, only we don't have to use reflection. No
8119         implementation yet.
8120
8121         * typemanager.cs (typecontainers): New hashtable to hold the corresponding
8122         typecontainer objects as we need to get at them.
8123         (TypeManager::AddUserType): Overload to take an extra argument, the TypeContainer.
8124
8125         * rootcontext.cs : Correspondingly modify called to AddUserType to pass the
8126         typecontainer object.
8127
8128         * expression.cs (MemberLookup): Modify signature to take a RootContext object instead
8129         of just a Report object.
8130
8131 2001-09-11  Ravi Pratap  <ravi@ximian.com>
8132
8133         * class.cs (Event::Define): Go back to using the prefixes "add_" and
8134         "remove_"
8135         (TypeContainer::Populate): Now define the delegates of the type too.
8136         (TypeContainer.Delegates): Property to access the list of delegates defined
8137         in the type.
8138
8139         * delegates.cs (Delegate::Define): Implement partially.
8140
8141         * modifiers.cs (TypeAttr): Handle more flags.
8142
8143 2001-09-11  Ravi Pratap  <ravi@ximian.com>
8144
8145         * class.cs (Indexer::Define): Fix for loop iteration condition to be just <
8146         and not <=
8147         (Operator::Define): Re-write logic to get types by using the LookupType method
8148         instead of blindly doing a Type.GetType ! How stupid can I get ;-) ?
8149         (Indexer::Define): Ditto.
8150         (Event::Define): Ditto.
8151         (Property::Define): Ditto.
8152
8153 2001-09-10  Ravi Pratap  <ravi@ximian.com>
8154
8155         * class.cs (TypeContainer::Populate): Now define operators too.
8156         (TypeContainer.Operators): New property to access the list of operators
8157         in a type.
8158         (Operator.OperatorMethodBuilder): New member to hold the method builder
8159         for the operator we are defining.
8160         (Operator::Define): Implement.
8161
8162 2001-09-10  Ravi Pratap  <ravi@ximian.com>
8163
8164         * class.cs (Event::Define): Make the prefixes of the accessor methods
8165         addOn_ and removeOn_
8166
8167         * genericparser.cs (GenericParser::error): Overloaded method to handle the case
8168         of the location being passed in too. Ideally, this should go later since all
8169         error reporting should be done through the Report object.
8170
8171         * class.cs (TypeContainer.Indexers): New property to access the list of indexers.
8172         (Populate): Iterate thru the indexers we have and define them too.
8173         (Indexer.GetMethodBuilder, .SetMethodBuilder): New members to hold the method builders
8174         for the get and set accessors.
8175         (Indexer::Define): Implement.
8176
8177 2001-09-09  Miguel de Icaza  <miguel@ximian.com>
8178
8179         * expression.cs (Binary::Resolve): Beginning of it.  I scratched
8180         my previous implementation, did not work.
8181
8182         * typemanager.cs: Add a couple of missing types (the longs).
8183
8184         * literal.cs: Use TypeManager.bool_type instead of getting it.
8185
8186         * expression.cs (EventExpr): New kind of expressions.
8187         (Expressio::ExprClassFromMemberInfo): finish
8188
8189 2001-09-08  Miguel de Icaza  <miguel@ximian.com>
8190
8191         * assign.cs: Emit stores to static fields differently.
8192
8193 2001-09-08  Ravi Pratap  <ravi@ximian.com>
8194
8195         * Merge in changes and adjust code to tackle conflicts. Backed out my
8196         code in Assign::Resolve ;-)
8197
8198 2001-09-08  Ravi Pratap  <ravi@ximian.com>
8199
8200         * cs-parser.jay (CheckAttributeTarget): Modify call to error to use
8201         instead Report.Error and also pass in the location.
8202         (CSharpParser::Lexer): New readonly property to return the reference
8203         to the Tokenizer object.
8204         (declare_local_variables): Use Report.Error with location instead of plain
8205         old error.
8206         (CheckDef): Ditto.
8207
8208         * class.cs (Operator::CheckUnaryOperator): Move into cs-parser.jay.
8209         (Operator.CheckBinaryOperator): Ditto.
8210
8211         * cs-parser.jay (operator_declarator): Update accordingly.
8212
8213         * cs-parser.jay (CheckUnaryOperator): Modify to use Report.Error
8214         (CheckBinaryOperator): Same here.
8215
8216         * rootcontext.cs (LookupType): Add an extra lookup which simply does a lookup
8217         on the name without any prefixes of namespace names etc. This is because we
8218         already might have something already fully qualified like
8219         'System.Console.WriteLine'
8220
8221         * assign.cs (Resolve): Begin implementation. Stuck ;-)
8222
8223 2001-09-07  Ravi Pratap  <ravi@ximian.com>
8224
8225         * cs-tokenizer.cs (location): Return a string which also contains
8226         the file name.
8227
8228         * expression.cs (ElementAccess): New class for expressions of the
8229         type 'element access.'
8230         (BaseAccess): New class for expressions of the type 'base access.'
8231         (CheckedExpr, UnCheckedExpr): New classes for Checked and Unchecked expressions
8232         respectively.
8233
8234         * cs-parser.jay (element_access): Implement action.
8235         (base_access): Implement actions.
8236         (checked_expression, unchecked_expression): Implement.
8237
8238         * cs-parser.jay (local_variable_type): Correct and implement.
8239         (type_suffixes, type_suffix_list, type_suffix): Implement actions.
8240
8241         * cs-tokenizer.cs (real_type_suffix): Comment out the extra getchar.
8242
8243         * cs-parser.jay (rank_specifiers): Remove space while concatenating the type's
8244         name and the specifiers.
8245
8246         * interface.cs (InterfaceAttr): New property to return the corresponding TypeAttributes
8247
8248         * rootcontext.cs (CreateInterface): Use the InterfaceAttr property instead of
8249         making them all public ;-)
8250
8251         * cs-parser.jay (error): Remove entirely as we have an implementation in the base
8252         class anyways.
8253
8254 2001-09-07  Miguel de Icaza  <miguel@ximian.com>
8255
8256         * expression.cs (ExprClassFromMemberInfo): Return FieldExpr and
8257         PropertyExprs.
8258         (FieldExpr, PropertyExprs): New resolved expressions.
8259         (SimpleName::MemberStaticCheck): Perform static checks for access
8260         to non-static fields on static methods. Maybe this should be
8261         generalized for MemberAccesses.
8262         (SimpleName::ResolveSimpleName): More work on simple name
8263         resolution.
8264
8265         * cs-parser.jay (primary_expression/qualified_identifier): track
8266         the parameter index.
8267
8268         * codegen.cs (CodeGen::Save): Catch save exception, report error.
8269         (EmitContext::EmitBoolExpression): Chain to expression generation
8270         instead of temporary hack.
8271         (::EmitStatementExpression): Put generic expression code generation.
8272
8273         * assign.cs (Assign::Emit): Implement variable assignments to
8274         local variables, parameters and fields.
8275
8276 2001-09-06  Miguel de Icaza  <miguel@ximian.com>
8277
8278         * statement.cs (Block::GetVariableInfo): New method, returns the
8279         VariableInfo for a variable name in a block.
8280         (Block::GetVariableType): Implement in terms of GetVariableInfo
8281
8282         * literal.cs (IntLiteral::Emit, FloatLiteral::Emit,
8283         DoubleLiteral::Emit, CharLiteral::Emit, BoolLiteral::Emit): Implement
8284
8285 2001-09-06  Ravi Pratap  <ravi@ximian.com>
8286
8287         * cs-parser.jay (operator_declaration): Continue on my quest : update
8288         to take attributes argument.
8289         (event_declaration): Ditto.
8290         (enum_declaration): Ditto.
8291         (indexer_declaration): Ditto.
8292
8293         * class.cs (Operator::Operator): Update constructor accordingly.
8294         (Event::Event): Ditto.
8295
8296         * delegate.cs (Delegate::Delegate): Same here.
8297
8298         * enum.cs (Enum::Enum): Same here.
8299
8300 2001-09-05  Ravi Pratap  <ravi@ximian.com>
8301
8302         * cs-parser.jay (CheckAttributeTarget): Update to use the right error number.
8303
8304         * ../tests/cs0658.cs : New file to demonstrate error 0658.
8305
8306         * attribute.cs (Attributes): New class to encapsulate all attributes which were
8307         being passed around as an arraylist.
8308         (Attributes::AddAttribute): Method to add attribute sections.
8309
8310         * cs-parser.jay (opt_attributes): Modify actions to use the new Attributes class.
8311         (struct_declaration): Update accordingly.
8312         (constant_declaration): Update.
8313         (field_declaration): Update.
8314         (method_header): Update.
8315         (fixed_parameter): Update.
8316         (parameter_array): Ditto.
8317         (property_declaration): Ditto.
8318         (destructor_declaration): Ditto.
8319
8320         * class.cs (Struct::Struct): Update constructors accordingly.
8321         (Class::Class): Ditto.
8322         (Field::Field): Ditto.
8323         (Method::Method): Ditto.
8324         (Property::Property): Ditto.
8325         (TypeContainer::OptAttribute): update property's return type.
8326
8327         * interface.cs (Interface.opt_attributes): New member.
8328         (Interface::Interface): Update to take the extra Attributes argument.
8329
8330         * parameter.cs (Parameter::Parameter): Ditto.
8331
8332         * constant.cs (Constant::Constant): Ditto.
8333
8334         * interface.cs (InterfaceMemberBase): New OptAttributes field.
8335         (InterfaceMemberBase::InterfaceMemberBase): Update constructor to take
8336         the attributes as a parameter.
8337         (InterfaceProperty): Update constructor call.
8338         (InterfaceEvent): Ditto.
8339         (InterfaceMethod): Ditto.
8340         (InterfaceIndexer): Ditto.
8341
8342         * cs-parser.jay (interface_indexer_declaration): Update call to constructor to
8343         pass the attributes too.
8344         (interface_event_declaration): Ditto.
8345         (interface_property_declaration): Ditto.
8346         (interface_method_declaration): Ditto.
8347         (interface_declaration): Ditto.
8348
8349 2001-09-05  Miguel de Icaza  <miguel@ximian.com>
8350
8351         * class.cs (Method::Define): Track the "static Main" definition to
8352         create an entry point.
8353
8354         * rootcontext.cs (RootContext::EntryPoint): MethodInfo that holds the
8355         EntryPoint if we find it.
8356
8357         * codegen.cs (EmitContext::EmitInvocation): Emit invocations.
8358         (EmitContext::ig): Make this variable public.
8359
8360         * driver.cs: Make the default output file be the first file name
8361         with the .exe extension.
8362
8363         Detect empty compilations
8364
8365         Handle various kinds of output targets.  Handle --target and
8366         rename -t to --dumper.
8367
8368         * expression.cs, literal.cs, assign.cs, constant.cs: All `Resolve'
8369         methods inherited from Expression return now an Expression.  This
8370         will is used during the tree rewriting as we resolve them during
8371         semantic analysis.
8372
8373         (Expression::MemberLookup): Implements the MemberLookup (7.3) from
8374         the spec.  Missing entirely is the information about
8375         accessability of elements of it.
8376
8377         (Expression::ExprClassFromMemberInfo): New constructor for
8378         Expressions that creates a fully initialized Expression based on
8379         a MemberInfo that is one of Eventinfo, FieldINfo, PropertyInfo or
8380         a Type.
8381
8382         (Invocation::Resolve): Begin implementing resolution of invocations.
8383
8384         * literal.cs (StringLiteral):  Implement Emit.
8385
8386 2001-09-05  Ravi Pratap  <ravi@ximian.com>
8387
8388         * cs-parser.jay (error): Add new modifier because we are hiding an inherited
8389         member.
8390
8391 2001-09-04  Ravi Pratap  <ravi@ximian.com>
8392
8393         * cs-parser.jay (attribute_arguments): Implement actions.
8394         (attribute): Fix bug in production. Implement action.
8395         (attribute_list): Implement.
8396         (attribute_target): Implement.
8397         (attribute_target_specifier, opt_target_specifier): Implement
8398         (CheckAttributeTarget): New method to check if the attribute target
8399         is valid.
8400         (attribute_section): Implement.
8401         (opt_attributes): Implement.
8402
8403         * attribute.cs : New file to handle attributes.
8404         (Attribute): Class to hold attribute info.
8405
8406         * cs-parser.jay (opt_attribute_target_specifier): Remove production
8407         (attribute_section): Modify production to use 2 different rules to
8408         achieve the same thing. 1 s/r conflict down !
8409         Clean out commented, useless, non-reducing dimension_separator rules.
8410
8411         * class.cs (TypeContainer.attributes): New member to hold list
8412         of attributes for a type.
8413         (Struct::Struct): Modify to take one more argument, the attribute list.
8414         (Class::Class): Ditto.
8415         (Field::Field): Ditto.
8416         (Method::Method): Ditto.
8417         (Property::Property): Ditto.
8418
8419         * cs-parser.jay (struct_declaration): Update constructor call to
8420         pass in the attributes too.
8421         (class_declaration): Ditto.
8422         (constant_declaration): Ditto.
8423         (field_declaration): Ditto.
8424         (method_header): Ditto.
8425         (fixed_parameter): Ditto.
8426         (parameter_array): Ditto.
8427         (property_declaration): Ditto.
8428
8429         * constant.cs (Constant::Constant): Update constructor similarly.
8430         Use System.Collections.
8431
8432         * parameter.cs (Parameter::Parameter): Update as above.
8433
8434 2001-09-02  Ravi Pratap  <ravi@ximian.com>
8435
8436         * class.cs (TypeContainer::AddDelegate): New method to add a delegate.
8437         (TypeContainer.delegates): New member to hold list of delegates.
8438
8439         * cs-parser.jay (delegate_declaration): Implement the action correctly
8440         this time as I seem to be on crack ;-)
8441
8442 2001-09-02  Miguel de Icaza  <miguel@ximian.com>
8443
8444         * rootcontext.cs (RootContext::IsNamespace): new function, used to
8445         tell whether an identifier represents a namespace.
8446
8447         * expression.cs (NamespaceExpr): A namespace expression, used only
8448         temporarly during expression resolution.
8449         (Expression::ResolveSimpleName, ::ResolvePrimary, ::ResolveName):
8450         utility functions to resolve names on expressions.
8451
8452 2001-09-01  Miguel de Icaza  <miguel@ximian.com>
8453
8454         * codegen.cs: Add hook for StatementExpressions.
8455
8456         * class.cs: Fix inverted test for static flag in methods.
8457
8458 2001-09-02  Ravi Pratap  <ravi@ximian.com>
8459
8460         * class.cs (Operator::CheckUnaryOperator): Correct error number used
8461         to make it coincide with MS' number.
8462         (Operator::CheckBinaryOperator): Ditto.
8463
8464         * ../errors/errors.txt : Remove error numbers added earlier.
8465
8466         * ../errors/cs1019.cs : Test case for error # 1019
8467
8468         * ../errros/cs1020.cs : Test case for error # 1020
8469
8470         * cs-parser.jay : Clean out commented cruft.
8471         (dimension_separators, dimension_separator): Comment out. Ostensibly not
8472         used anywhere - non-reducing rule.
8473         (namespace_declarations): Non-reducing rule - comment out.
8474
8475         * enum.cs (Enum::AddEnum): Rename to AddEnumMember as I was getting confused
8476         with TypeContainer::AddEnum.
8477
8478         * delegate.cs : New file for delegate handling classes.
8479         (Delegate): Class for declaring delegates.
8480
8481         * makefile : Update.
8482
8483         * cs-parser.jay (delegate_declaration): Implement.
8484
8485 2001-09-01  Ravi Pratap  <ravi@che.iitm.ac.in>
8486
8487         * class.cs (Event::Define): Implement.
8488         (Event.EventBuilder): New member.
8489
8490         * class.cs (TypeContainer::Populate): Update to define all enums and events
8491         we have.
8492         (Events): New property for the events arraylist we hold. Shouldn't we move to using
8493         readonly fields for all these cases ?
8494
8495 2001-08-31  Ravi Pratap  <ravi@che.iitm.ac.in>
8496
8497         * class.cs (Property): Revamp to use the convention of making fields readonly.
8498         Accordingly modify code elsewhere.
8499
8500         * class.cs : Apply patch from Mr. Mandar <go_mono@hotmail.com> for implementing
8501         the Define method of the Property class.
8502
8503         * class.cs : Clean up applied patch and update references to variables etc. Fix
8504         trivial bug.
8505         (TypeContainer::Populate): Update to define all the properties we have. Also
8506         define all enumerations.
8507
8508         * enum.cs (Define): Implement.
8509
8510 2001-08-31  Ravi Pratap  <ravi@che.iitm.ac.in>
8511
8512         * cs-parser.jay (overloadable_operator): The semantic value is an
8513         enum of the Operator class.
8514         (operator_declarator): Implement actions.
8515         (operator_declaration): Implement.
8516
8517         * class.cs (Operator::CheckUnaryOperator): New static method to help in checking
8518         validity of definitions.
8519         (Operator::CheckBinaryOperator): Static method to check for binary operators
8520         (TypeContainer::AddOperator): New method to add an operator to a type.
8521
8522         * cs-parser.jay (indexer_declaration): Added line to actually call the
8523         AddIndexer method so it gets added ;-)
8524
8525         * ../errors/errors.txt : Update to include new error numbers. Are these numbers
8526         already taken care of by the MS compiler ?
8527
8528 2001-08-29  Ravi Pratap  <ravi@che.iitm.ac.in>
8529
8530         * class.cs (Operator): New class for operator declarations.
8531         (Operator::OpType): Enum for the various operators.
8532
8533 2001-08-29  Ravi Pratap  <ravi@che.iitm.ac.in>
8534
8535         * class.cs (TypeContainer::AddIndexer): Remove FIXME comment. We
8536         ostensibly handle this in semantic analysis.
8537
8538         * cs-parser.jay (general_catch_clause): Comment out
8539         (specific_catch_clauses, specific_catch_clause): Ditto.
8540         (opt_general_catch_clause, opt_specific_catch_clauses): Ditto
8541         (catch_args, opt_catch_args): New productions.
8542         (catch_clause): Rewrite to use the new productions above
8543         (catch_clauses): Modify accordingly.
8544         (opt_catch_clauses): New production to use in try_statement
8545         (try_statement): Revamp. Basically, we get rid of one unnecessary rule
8546         and re-write the code in the actions to extract the specific and
8547         general catch clauses by being a little smart ;-)
8548
8549         * ../tests/try.cs : Fix. It's not 'finalize' my friend, it's 'finally' !
8550         Hooray, try and catch statements parse fine !
8551
8552 2001-08-28  Ravi Pratap  <ravi@che.iitm.ac.in>
8553
8554         * statement.cs (Block::GetVariableType): Fix logic to extract the type
8555         string from the hashtable of variables.
8556
8557         * cs-parser.jay (event_accessor_declarations): Trivial fix. Man, how did
8558         I end up making that mistake ;-)
8559         (catch_clauses): Fixed gross error which made Key and Value of the
8560         DictionaryEntry the same : $1 !!
8561
8562 2001-08-28  Ravi Pratap  <ravi@che.iitm.ac.in>
8563
8564         * cs-tokenizer.cs (initTokens): Add keywords 'add' and 'remove'
8565
8566         * cs-parser.jay (event_declaration): Correct to remove the semicolon
8567         when the add and remove accessors are specified.
8568
8569 2001-08-28  Ravi Pratap  <ravi@che.iitm.ac.in>
8570
8571         * cs-parser.jay (IndexerDeclaration): New helper class to hold
8572         information about indexer_declarator.
8573         (indexer_declarator): Implement actions.
8574         (parsing_indexer): New local boolean used to keep track of whether
8575         we are parsing indexers or properties. This is necessary because
8576         implicit_parameters come into picture even for the get accessor in the
8577         case of an indexer.
8578         (get_accessor_declaration, set_accessor_declaration): Correspondingly modified.
8579
8580         * class.cs (Indexer): New class for indexer declarations.
8581         (TypeContainer::AddIndexer): New method to add an indexer to a type.
8582         (TypeContainer::indexers): New member to hold list of indexers for the
8583         type.
8584
8585 2001-08-27  Ravi Pratap  <ravi@che.iitm.ac.in>
8586
8587         * cs-parser.jay (add_accessor_declaration): Implement action.
8588         (remove_accessor_declaration): Implement action.
8589         (event_accessors_declaration): Implement
8590         (variable_declarators): swap statements for first rule - trivial.
8591
8592         * class.cs (Event): New class to hold information about event
8593         declarations.
8594         (TypeContainer::AddEvent): New method to add an event to a type
8595         (TypeContainer::events): New member to hold list of events.
8596
8597         * cs-parser.jay (event_declaration): Implement actions.
8598
8599 2001-08-27  Ravi Pratap  <ravi@che.iitm.ac.in>
8600
8601         * cs-parser.jay (dim_separators): Implement. Make it a string
8602         concatenating all the commas together, just as they appear.
8603         (opt_dim_separators): Modify accordingly
8604         (rank_specifiers): Update accordingly. Basically do the same
8605         thing - instead, collect the brackets here.
8606         (opt_rank_sepcifiers): Modify accordingly.
8607         (array_type): Modify to actually return the complete type string
8608         instead of ignoring the rank_specifiers.
8609         (expression_list): Implement to collect the expressions
8610         (variable_initializer): Implement. We make it a list of expressions
8611         essentially so that we can handle the array_initializer case neatly too.
8612         (variable_initializer_list): Implement.
8613         (array_initializer): Make it a list of variable_initializers
8614         (opt_array_initializer): Modify accordingly.
8615
8616         * expression.cs (New::NType): Add enumeration to help us
8617         keep track of whether we have an object/delegate creation
8618         or an array creation.
8619         (New:NewType, New::Rank, New::Indices, New::Initializers): New
8620         members to hold data about array creation.
8621         (New:New): Modify to update NewType
8622         (New:New): New Overloaded contructor for the array creation
8623         case.
8624
8625         * cs-parser.jay (array_creation_expression): Implement to call
8626         the overloaded New constructor.
8627
8628 2001-08-26  Ravi Pratap  <ravi@che.iitm.ac.in>
8629
8630         * class.cs (TypeContainer::Constructors): Return member
8631         constructors instead of returning null.
8632
8633 2001-08-26  Miguel de Icaza  <miguel@ximian.com>
8634
8635         * typemanager.cs (InitCoreTypes): Initialize the various core
8636         types after we have populated the type manager with the user
8637         defined types (this distinction will be important later while
8638         compiling corlib.dll)
8639
8640         * expression.cs, literal.cs, assign.cs, constant.cs: Started work
8641         on Expression Classification.  Now all expressions have a method
8642         `Resolve' and a method `Emit'.
8643
8644         * codegen.cs, cs-parser.jay: Fixed the bug that stopped code
8645         generation from working.     Also add some temporary debugging
8646         code.
8647
8648 2001-08-24  Miguel de Icaza  <miguel@ximian.com>
8649
8650         * codegen.cs: Lots of code generation pieces.  This is only the
8651         beginning, will continue tomorrow with more touches of polish.  We
8652         handle the fundamentals of if, while, do, for, return.  Others are
8653         trickier and I need to start working on invocations soon.
8654
8655         * gen-treedump.cs: Bug fix, use s.Increment here instead of
8656         s.InitStatement.
8657
8658         * codegen.cs (EmitContext): New struct, used during code
8659         emission to keep a context.   Most of the code generation will be
8660         here.
8661
8662         * cs-parser.jay: Add embedded blocks to the list of statements of
8663         this block.  So code generation proceeds in a top down fashion.
8664
8665 2001-08-23  Miguel de Icaza  <miguel@ximian.com>
8666
8667         * statement.cs: Add support for multiple child blocks.
8668
8669 2001-08-22  Miguel de Icaza  <miguel@ximian.com>
8670
8671         * codegen.cs (EmitCode): New function, will emit the code for a
8672         Block of code given a TypeContainer and its ILGenerator.
8673
8674         * statement.cs (Block): Standard public readonly optimization.
8675         (Block::Block constructors): Link children.
8676         (Block::Child): Child Linker.
8677         (Block::EmitVariables): Emits IL variable declarations.
8678
8679         * class.cs: Drop support for MethodGroups here, delay until
8680         Semantic Analysis.
8681         (Method::): Applied the same simplification that I did before, and
8682         move from Properties to public readonly fields.
8683         (Method::ParameterTypes): Returns the parameter types for the
8684         function, and implements a cache that will be useful later when I
8685         do error checking and the semantic analysis on the methods is
8686         performed.
8687         (Constructor::GetCallingConvention): Renamed from CallingConvetion
8688         and made a method, optional argument tells whether this is a class
8689         or a structure to apply the `has-this' bit.
8690         (Method::GetCallingConvention): Implement, returns the calling
8691         convention.
8692         (Method::Define): Defines the type, a second pass is performed
8693         later to populate the methods.
8694
8695         (Constructor::ParameterTypes): implement a cache similar to the
8696         one on Method::ParameterTypes, useful later when we do semantic
8697         analysis.
8698
8699         (TypeContainer::EmitMethod):  New method.  Emits methods.
8700
8701         * expression.cs: Removed MethodGroup class from here.
8702
8703         * parameter.cs (Parameters::GetCallingConvention): new method.
8704
8705 2001-08-21  Miguel de Icaza  <miguel@ximian.com>
8706
8707         * class.cs (TypeContainer::Populate): Drop RootContext from the
8708         argument.
8709
8710         (Constructor::CallingConvention): Returns the calling convention.
8711         (Constructor::ParameterTypes): Returns the constructor parameter
8712         types.
8713
8714         (TypeContainer::AddConstructor): Keep track of default constructor
8715         and the default static constructor.
8716
8717         (Constructor::) Another class that starts using `public readonly'
8718         instead of properties.
8719
8720         (Constructor::IsDefault): Whether this is a default constructor.
8721
8722         (Field::) use readonly public fields instead of properties also.
8723
8724         (TypeContainer::TypeAttr, TypeContainer::AddConstructor): Keep
8725         track of static constructors;  If none is used, turn on
8726         BeforeFieldInit in the TypeAttributes.
8727
8728         * cs-parser.jay (opt_argument_list): now the return can be null
8729         for the cases where there are no arguments.
8730
8731         (constructor_declarator): If there is no implicit `base' or
8732         `this', then invoke the default parent constructor.
8733
8734         * modifiers.cs (MethodAttr): New static function maps a set of
8735         modifiers flags into a MethodAttributes enum
8736         (FieldAttr): renamed from `Map'.  So now we have FieldAttr,
8737         MethodAttr, TypeAttr to represent the various mappings where the
8738         modifiers are used.
8739         (FieldAttr): Map also `readonly' to `FieldAttributes.InitOnly'
8740
8741 2001-08-19  Miguel de Icaza  <miguel@ximian.com>
8742
8743         * parameter.cs (GetParameterInfo): Fix bug where there would be no
8744         method arguments.
8745
8746         * interface.cs (PopulateIndexer): Implemented the code generator
8747         for interface indexers.
8748
8749 2001-08-17  Miguel de Icaza  <miguel@ximian.com>
8750
8751         * interface.cs (InterfaceMemberBase): Now we track the new status
8752         here.
8753
8754         (PopulateProperty): Implement property population.  Woohoo!  Got
8755         Methods and Properties going today.
8756
8757         Removed all the properties for interfaces, and replaced them with
8758         `public readonly' fields.
8759
8760 2001-08-16  Miguel de Icaza  <miguel@ximian.com>
8761
8762         * interface.cs (AddEvent, AddMethod, AddIndexer, AddProperty):
8763         initialize their hashtables/arraylists only when they are needed
8764         instead of doing this always.
8765
8766         * parameter.cs: Handle refs and out parameters.
8767
8768         * cs-parser.jay: Use an ArrayList to construct the arguments
8769         instead of the ParameterCollection, and then cast that to a
8770         Parameter[] array.
8771
8772         * parameter.cs: Drop the use of ParameterCollection and use
8773         instead arrays of Parameters.
8774
8775         (GetParameterInfo): Use the Type, not the Name when resolving
8776         types.
8777
8778 2001-08-13  Miguel de Icaza  <miguel@ximian.com>
8779
8780         * parameter.cs: Eliminate the properties Name, Type and ModFlags,
8781         and instead use public readonly fields.
8782
8783         * class.cs: Put back walking code for type containers.
8784
8785 2001-08-11  Miguel de Icaza  <miguel@ximian.com>
8786
8787         * class.cs (MakeConstant): Code to define constants.
8788
8789         * rootcontext.cs (LookupType): New function.  Used to locate types
8790
8791
8792 2001-08-08  Miguel de Icaza  <miguel@ximian.com>
8793
8794         * rootcontext.cs: OH MY!  My trick works!   It is amazing how nice
8795         this System.Reflection code is.  Kudos to Microsoft
8796
8797         * typemanager.cs: Implement a type cache and avoid loading all
8798         types at boot time.  Wrap in LookupType the internals.  This made
8799         the compiler so much faster.  Wow.  I rule!
8800
8801         * driver.cs: Make sure we always load mscorlib first (for
8802         debugging purposes, nothing really important).
8803
8804         * Renamespaced things that were on `CSC' to `CIR'.  Maybe I should
8805         have moved to `CSC' rather than `CIR'.  Oh man!  The confussion!
8806
8807         * rootcontext.cs: Lookup types on their namespace;  Lookup types
8808         on namespaces that have been imported using the `using' keyword.
8809
8810         * class.cs (TypeContainer::TypeAttr): Virtualize.
8811         (Class::TypeAttr): Return attributes suitable for this bad boy.
8812         (Struct::TypeAttr): ditto.
8813         Handle nested classes.
8814         (TypeContainer::) Remove all the type visiting code, it is now
8815         replaced with the rootcontext.cs code
8816
8817         * rootcontext.cs (GetClassBases): Added support for structs.
8818
8819 2001-08-06  Miguel de Icaza  <miguel@ximian.com>
8820
8821         * interface.cs, statement.cs, class.cs, parameter.cs,
8822         rootcontext.cs, gen-treedump.cs, enum.cs, cs-parse.jay:
8823         Drop use of TypeRefs, and use strings instead.
8824
8825 2001-08-04  Miguel de Icaza  <miguel@ximian.com>
8826
8827         * rootcontext.cs:
8828
8829         * class.cs (Struct::Struct): set the SEALED flags after
8830         checking the modifiers.
8831         (TypeContainer::TypeAttr): new property, returns the
8832         TypeAttributes for a class.
8833
8834         * cs-parser.jay (type_list): Oops, list production was creating a
8835         new list of base types.
8836
8837         * rootcontext.cs (StdLib): New property.
8838         (GetInterfaceTypeByName): returns an interface by type name, and
8839         encapsulates error handling here.
8840         (GetInterfaces): simplified.
8841         (ResolveTree): Encapsulated all the tree resolution here.
8842         (CreateClass, GetClassBases, GetInterfaceOrClass): Create class
8843         types.
8844
8845         * driver.cs: Add support for --nostdlib, to avoid loading the
8846         default assemblies.
8847         (Main): Do not put tree resolution here.
8848
8849         * rootcontext.cs: Beginning of the class resolution.
8850
8851 2001-08-03  Miguel de Icaza  <miguel@ximian.com>
8852
8853         * rootcontext.cs: Provide better error reporting.
8854
8855         * cs-parser.jay (interface_base): set our $$ to be interfaces.
8856
8857         * rootcontext.cs (CreateInterface): Handle the case where there
8858         are no parent interfaces.
8859
8860         (CloseTypes): Routine to flush types at the end.
8861         (CreateInterface): Track types.
8862         (GetInterfaces): Returns an array of Types from the list of
8863         defined interfaces.
8864
8865         * typemanager.c (AddUserType): Mechanism to track user types (puts
8866         the type on the global type hash, and allows us to close it at the
8867         end).
8868
8869 2001-08-02  Miguel de Icaza  <miguel@ximian.com>
8870
8871         * tree.cs: Removed RecordType, added RecordClass, RecordStruct and
8872         RecordInterface instead.
8873
8874         * cs-parser.jay: Updated to reflect changes above.
8875
8876         * decl.cs (Definition): Keep track of the TypeBuilder type that
8877         represents this type here.  Not sure we will use it in the long
8878         run, but wont hurt for now.
8879
8880         * driver.cs: Smaller changes to accomodate the new code.
8881
8882         Call ResolveInterfaceBases, Call ResolveClassBases, Save assembly
8883         when done.
8884
8885         * rootcontext.cs (CreateInterface):  New method, used to create
8886         the System.TypeBuilder type for interfaces.
8887         (ResolveInterfaces): new entry point to resolve the interface
8888         hierarchy.
8889         (CodeGen): Property, used to keep track of the code generator.
8890
8891 2001-07-26  Miguel de Icaza  <miguel@ximian.com>
8892
8893         * cs-parser.jay: Add a second production for delegate_declaration
8894         with `VOID'.
8895
8896         (enum_body): Put an opt_comma here instead of putting it on
8897         enum_body or enum_member_declarations so we can handle trailing
8898         commas on enumeration members.  Gets rid of a shift/reduce.
8899
8900         (type_list): Need a COMMA in the middle.
8901
8902         (indexer_declaration): Tell tokenizer to recognize get/set
8903
8904         * Remove old targets.
8905
8906         * Re-add the parser target.
8907
8908 2001-07-13  Simon Cozens <simon@simon-cozens.org>
8909
8910         * cs-parser.jay: Add precendence rules for a number of operators
8911         ot reduce the number of shift/reduce conflicts in the grammar.
8912
8913 2001-07-17  Miguel de Icaza  <miguel@ximian.com>
8914
8915         * tree.cs: moved IGenerator interface and renamed it to ITreeDump
8916         and put it here.
8917
8918         Get rid of old crufty code.
8919
8920         * rootcontext.cs: Use this to keep track of the parsed
8921         representation and the defined types available to the program.
8922
8923         * gen-treedump.cs: adjust for new convention.
8924
8925         * type.cs: Split out the type manager, and the assembly builder
8926         from here.
8927
8928         * typemanager.cs: the type manager will live here now.
8929
8930         * cil-codegen.cs: And the code generator here.
8931
8932 2001-07-14  Sean MacIsaac  <macisaac@ximian.com>
8933
8934         * makefile: Fixed up for easy making.
8935
8936 2001-07-13  Simon Cozens <simon@simon-cozens.org>
8937
8938         * cs-parser.jay (rank_specifier): Remove a conflict by reordering
8939         the
8940
8941         (unary_expression): Expand pre_increment_expression and
8942         post_decrement_expression to reduce a shift/reduce.
8943
8944 2001-07-11  Simon Cozens
8945
8946         * cs-tokenizer.cs: Hex numbers should begin with a 0.
8947
8948         Improve allow_keyword_as_indent name.
8949
8950 2001-06-19  Miguel de Icaza  <miguel@ximian.com>
8951
8952         * Adjustments for Beta2.
8953
8954 2001-06-13  Miguel de Icaza  <miguel@ximian.com>
8955
8956         * decl.cs: Added `Define' abstract method.
8957         (InTransit): new property, used to catch recursive definitions.
8958
8959         * interface.cs: Implement `Define'.
8960
8961         * modifiers.cs: Map Modifiers.constants to
8962         System.Reflection.TypeAttribute flags.
8963
8964         * class.cs: Keep track of types and user-defined types.
8965         (BuilderInit): New method for creating an assembly
8966         (ResolveType): New function to launch the resolution process, only
8967         used by interfaces for now.
8968
8969         * cs-parser.jay: Keep track of Classes, Structs and Interfaces
8970         that are inserted into the name space.
8971
8972 2001-06-08  Miguel de Icaza  <miguel@ximian.com>
8973
8974         * ARGH.  I have screwed up my tree so many times due to the use of
8975         rsync rather than using CVS.  Going to fix this at once.
8976
8977         * driver.cs: Objetify driver.  Load assemblies, use assemblies to
8978         load types.
8979
8980 2001-06-07  Miguel de Icaza  <miguel@ximian.com>
8981
8982         * Experiment successful: Use System.Type rather that our own
8983         version of Type.
8984
8985 2001-05-25  Miguel de Icaza  <miguel@ximian.com>
8986
8987         * cs-parser.jay: Removed nsAliases from here.
8988
8989         Use new namespaces, handle `using XXX;'
8990
8991         * namespace.cs: Reimplemented namespace handling, use a recursive
8992         definition of the class.  Now we can keep track of using clauses
8993         and catch invalid using clauses.
8994
8995 2001-05-24  Miguel de Icaza  <miguel@ximian.com>
8996
8997         * gen-treedump.cs: Adapted for all the renaming.
8998
8999         * expression.cs (Expression): this class now has a Type property
9000         which returns an expression Type.
9001
9002         (Probe::, New::, TypeOf::, SizeOf::, Constant::): renamed from
9003         `Type', as this has a different meaning now in the base
9004
9005 2001-05-22  Miguel de Icaza  <miguel@ximian.com>
9006
9007         * interface.cs, class.cs: Removed from all the sources the
9008         references to signature computation, as we can not do method
9009         signature computation during the parsing time, as we are not
9010         trying to solve at that point distinguishing:
9011
9012         class X {
9013                 void a (Blah x) {}
9014                 void a (NS.Blah x) {}
9015         }
9016
9017         Which depending on the context might be valid or not, as we do not
9018         know if Blah is the same thing as NS.Blah at that point.
9019
9020         * Redid everything so the code uses TypeRefs now instead of
9021         Types.  TypeRefs are just temporary type placeholders, that need
9022         to be resolved.  They initially have a pointer to a string and the
9023         current scope in which they are used.  This is used later by the
9024         compiler to resolve the reference to an actual Type.
9025
9026         * DeclSpace is no longer a CIR.Type, and neither are
9027         TypeContainers (Class and Struct) nor Interfaces nor Enums.  They
9028         are all DeclSpaces, but no Types.
9029
9030         * type.cs (TypeRefManager): This implements the TypeRef manager,
9031         which keeps track of all the types that need to be resolved after
9032         the parsing has finished.
9033
9034 2001-05-13  Miguel de Icaza  <miguel@ximian.com>
9035
9036         * ARGH.  We are going to have to store `foreach' as a class rather
9037         than resolving it, as we need to verify error 1579 after name
9038         resolution.   *OR* we could keep a flag that says `This request to
9039         IEnumerator comes from a foreach statement' which we can then use
9040         to generate the error.
9041
9042 2001-05-10  Miguel de Icaza  <miguel@ximian.com>
9043
9044         * class.cs (TypeContainer.AddMethod): we now add methods to the
9045         MethodGroup instead of the method hashtable.
9046
9047         * expression.cs: Add MethodGroup abstraction, which gets us one
9048         step closer to the specification in the way we handle method
9049         declarations.
9050
9051         * cs-parser.jay (primary_expression): qualified_identifier now
9052         tried to match up an identifier to a local variable reference or
9053         to a parameter reference.
9054
9055         current_local_parameters is now a parser global variable that
9056         points to the current parameters for the block, used during name
9057         lookup.
9058
9059         (property_declaration): Now creates an implicit `value' argument to
9060         the set accessor.
9061
9062 2001-05-09  Miguel de Icaza  <miguel@ximian.com>
9063
9064         * parameter.cs: Do not use `param' arguments as part of the
9065         signature, per the spec.
9066
9067 2001-05-08  Miguel de Icaza  <miguel@ximian.com>
9068
9069         * decl.cs: Base class for classes, structs and interfaces.  This
9070         is the "Declaration Space"
9071
9072         * cs-parser.jay: Use CheckDef for checking declaration errors
9073         instead of having one on each function.
9074
9075         * class.cs: Factor out some code for handling error handling in
9076         accordance to the "Declarations" section in the "Basic Concepts"
9077         chapter in the ECMA C# spec.
9078
9079         * interface.cs: Make all interface member classes derive from
9080         InterfaceMemberBase.
9081
9082 2001-05-07  Miguel de Icaza  <miguel@ximian.com>
9083
9084         * Many things: all interfaces are parsed and generated in
9085         gen-treedump.  Support for member variables, constructors,
9086         destructors, properties, constants is there.
9087
9088         Beginning of the IL backend, but very little done, just there for
9089         testing purposes.
9090
9091 2001-04-29  Miguel de Icaza  <miguel@ximian.com>
9092
9093         * cs-parser.jay: Fix labeled statement.
9094
9095         * cs-tokenizer.cs (escape): Escape " and ' always.
9096         ref_line, ref_name: keep track of the line/filename as instructed
9097         by #line by the compiler.
9098         Parse #line.
9099
9100 2001-04-27  Miguel de Icaza  <miguel@ximian.com>
9101
9102         * System.CodeDOM/CodeBinaryOperatorExpression.cs: Rearrange enum
9103         to match the values in System.CodeDOM.
9104
9105         Divid renamed to Divide.
9106
9107         * System.CodeDOM/CodeForLoopStatement.cs: Always have valid
9108         statements.
9109         (Statements.set): remove.
9110
9111         * System.CodeDOM/CodeCatchClause.cs: always have a valid
9112         statements.
9113
9114         * System.CodeDOM/CodeIfStatement.cs: trueStatements and
9115         falseStatements always have valid values.
9116
9117         * cs-parser.jay: Use System.CodeDOM now.
9118