+2002-06-27 Martin Baulig <martin@gnome.org>
+
+ * ecore.cs (Expression.ImplicitReferenceConversionExists): Use
+ `target_type == TypeManager.array_type', not IsAssignableFrom() in
+ the "from an array-type to System.Array" case. This makes it work
+ when compiling corlib.
+
+2002-06-27 Martin Baulig <martin@gnome.org>
+
+ * ecore.cs (Expression.SimpleNameResolve): If the expression is a
+ non-static PropertyExpr, set its InstanceExpression. This makes
+ the `ICollection.Count' property work in System/Array.cs.
+
+2002-06-25 Andrew Birkett <adb@tardis.ed.ac.uk>
+
+ * driver.cs: Made error handling more consistent. Errors now
+ tracked by Report class, so many methods which used to return int
+ now return void. Main() now prints success/failure and
+ errors/warnings message.
+
+ Renamed '--probe' compiler argument to '--expect-error'. Removed
+ the magic number return values (123 and 124). Now, if the
+ expected error occurs, the compiler exits with success (exit value
+ 0). If the compilation completes without seeing that particular
+ error, the compiler exits with failure (exit value 1). The
+ makefile in mcs/errors has been changed to handle the new behaviour.
+
+ * report.cs: Made 'expected error' number a property and renamed
+ it from 'Probe' to 'ExpectedError'.
+
+ * genericparser.cs: Removed error handling support, since it is
+ now all done by Report class.
+
+ * cs-parser.jay, mb-parser.jay: Errors are tracked by Report
+ class, so parse() no longer returns an int.
+
+ * namespace.cs: Use Report.Error instead of GenericParser.error
+
+
+2002-06-22 Miguel de Icaza <miguel@ximian.com>
+
+ * class.cs (TypeContainer.AddMethod, TypeContainer.AddIndexer,
+ TypeContainer.AddOperator): At the front of the list put the
+ explicit implementations, so they get resolved/defined first.
+
+2002-06-21 Miguel de Icaza <miguel@ximian.com>
+
+ * class.cs (TypeContainer.VerifyImplements): Verifies that a given
+ interface type is implemented by this TypeContainer. Used during
+ explicit interface implementation.
+
+ (Property.Define, Indexer.Define, Method.Define): Validate that
+ the given interface in the explicit implementation is one of the
+ base classes for the containing type.
+
+ Also if we are explicitly implementing an interface, but there is
+ no match in the pending implementation table, report an error.
+
+ (Property.Define): Only define the property if we are
+ not explicitly implementing a property from an interface. Use the
+ correct name also for those properties (the same CSC uses,
+ although that is really not needed).
+
+ (Property.Emit): Do not emit attributes for explicitly implemented
+ properties, as there is no TypeBuilder.
+
+ (Indexer.Emit): ditto.
+
+ Hiding then means that we do not really *implement* a pending
+ implementation, which makes code fail.
+
+2002-06-22 Martin Baulig <martin@gnome.org>
+
+ * ecore.cs (Expression.Constantify): Call TypeManager.TypeToCoreType() on
+ the return value of Object.GetType(). [FIXME: we need to do this whenever
+ we get a type back from the reflection library].
+
+Fri Jun 21 13:37:57 CEST 2002 Paolo Molaro <lupus@ximian.com>
+
+ * typemanager.cs: make ExpandInterfaces() slip duplicated interfaces.
+
+2002-06-20 Miguel de Icaza <miguel@ximian.com>
+
+ * attribute.cs: Return null if we can not look up the type.
+
+ * class.cs (TypeContainer.GetClassBases): Use ExpandInterfaces on
+ the interface types found.
+
+ * interface.cs (Interface.GetInterfaceBases): Use ExpandInterfaces on the
+ interface types found.
+
+ * typemanager.cs (GetInterfaces): Make this routine returns alll
+ the interfaces and work around the lame differences between
+ System.Type and System.Reflection.Emit.TypeBuilder in the results
+ result for GetInterfaces.
+
+ (ExpandInterfaces): Given an array of interface types, expand and
+ eliminate repeated ocurrences of an interface. This expands in
+ context like: IA; IB : IA; IC : IA, IB; the interface "IC" to
+ be IA, IB, IC.
+
+2002-06-21 Martin Baulig <martin@gnome.org>
+
+ * typemanager.cs (TypeManager.EnumToUnderlying): It's now safe to call this function
+ on System.Enum.
+
+2002-06-21 Martin Baulig <martin@gnome.org>
+
+ * typemanager.cs (TypeManager.TypeToCoreType): New function. When compiling corlib
+ and called with one of the core types, return the corresponding typebuilder for
+ that type.
+
+ * expression.cs (ArrayAccess.DoResolve): Call TypeManager.TypeToCoreType() on the
+ element type.
+
+2002-06-21 Martin Baulig <martin@gnome.org>
+
+ * ecore.cs (Expression.ExplicitReferenceConversionExists): Use
+ `target_type.IsArray' instead of `target_type.IsSubclassOf (TypeManager.array_type)'.
+ (Expression.ConvertReferenceExplicit): Likewise.
+
+ * expression.cs (ElementAccess.DoResolve): Likewise.
+ (ElementAccess.DoResolveLValue): Likewise.
+
+2002-06-10 Martin Baulig <martin@gnome.org>
+
+ * interface.cs (Interface.PopulateIndexer): When creating the setter, we need to
+ add the "value" parameter to the parameter list.
+
+ * statement.cs (Fixed.Emit): Pass the return value of the child block's Emit()
+ to our caller.
+
+2002-06-19 Miguel de Icaza <miguel@ximian.com>
+
+ * expression.cs (ArrayCreation.ExpressionToArrayArgument): Convert
+ the argument to an int, uint, long or ulong, per the spec. Also
+ catch negative constants in array creation.
+
+Thu Jun 20 17:56:48 CEST 2002 Paolo Molaro <lupus@ximian.com>
+
+ * class.cs: do not allow the same interface to appear twice in
+ the definition list.
+
+Wed Jun 19 22:33:37 CEST 2002 Paolo Molaro <lupus@ximian.com>
+
+ * ecore.cs: don't use ldlen with System.Array.
+
+Wed Jun 19 20:57:40 CEST 2002 Paolo Molaro <lupus@ximian.com>
+
+ * ecore.cs: stobj requires a type argument. Handle indirect stores on enums.
+
+Wed Jun 19 20:17:59 CEST 2002 Paolo Molaro <lupus@ximian.com>
+
+ * modifiers.cs: produce correct field attributes for protected
+ internal. Easy fix so miguel can work on ther harder stuff:-)
+
+2002-06-18 Miguel de Icaza <miguel@ximian.com>
+
+ * pending.cs: New file. Move the code from class.cs here.
+ Support clearning the pending flag for all methods (when not doing
+ explicit interface implementation).
+
+Tue Jun 18 10:36:22 CEST 2002 Paolo Molaro <lupus@ximian.com>
+
+ * rootcontext.cs: added a couple more types needed to bootstrap.
+
+2002-06-17 Miguel de Icaza <miguel@ximian.com>
+
+ * typemanager.cs (GetConstructor): Use DeclaredOnly to look the
+ constructor in the type, instead of any constructor in the type
+ hierarchy. Thanks to Paolo for finding this bug (it showed up as
+ a bug in the Mono runtime when applying the params attribute).
+
+2002-06-16 Rafael Teixeira <rafaelteixeirabr@hotmail.com>
+ * changed namespace.cs to use "GenericParser.error(...)" instead of "CSharpParser.error(...)"
+
+2002-06-14 Rachel Hestilow <hestilow@ximian.com>
+
+ * expression.cs (Unary.ResolveOperator): Use TypeManager
+ to resolve the type.
+
+2002-06-13 Ravi Pratap <ravi@ximian.com>
+
+ * cs-parser.jay (enum_member_declaration): Pass in the attributes
+ attached.
+
+ * enum.cs (AddEnumMember): Add support to store the attributes associated
+ with each member too.
+
+ * attribute.cs (CheckAttribute, ApplyAttributes): Update to handle
+ field builders too - this takes care of the enum member case.
+
+2002-06-10 Rachel Hestilow <hestilow@ximian.com>
+
+ * typemanager.cs (TypeManager.VerifyUnManaged): Allow
+ address-of operator on both value types and pointers.
+
+2002-06-10 Martin Baulig <martin@gnome.org>
+
+ * interface.cs (Interface.PopulateIndexer): Add the indexer's
+ PropertyBuilder to the `property_builders' list.
+
+ * expression.cs (Indexers.GetIndexersForTypeOrInterface): New private method.
+ (Indexers.GetIndexersForType): Call GetIndexersForTypeOrInterface() on the
+ `lookup_type' and all its interfaces. Unfortunately, Type.FindMembers() won't
+ find any indexers which are inherited from an interface.
+
+2002-06-09 Martin Baulig <martin@gnome.org>
+
+ * const.cs (Const.LookupConstantValue): Convert `Expr' to a literal of
+ the same type as the constant if necessary. There's also a test-130.cs
+ for this.
+
+ * enum.cs (Enum.ChangeEnumType): Moved to typemanager.cs and made public.
+
+ * typemanager.cs (TypeManager.ChangeType): Previously known as
+ Enum.ChangeEnumType().
+
+2002-06-09 Martin Baulig <martin@gnome.org>
+
+ * expression.cs (Cast.TryReduce): Added support for consts.
+
+2002-06-08 Ravi Pratap <ravi@ximian.com>
+
+ * class.cs (Accessor): Hold attributes information so we can pass
+ it along.
+
+ * cs-parser.jay (get_accessor_declaration, set_accessor_declaration):
+ Modify to pass in attributes attached to the methods.
+
+ (add_accessor_declaration, remove_accessor_declaration): Ditto.
+
+ * attribute.cs (ApplyAttributes, CheckAttribute): Update accordingly
+ to handle the Accessor kind :-)
+
+ * class.cs (Property.Emit, Event.Emit): Apply attributes to the accessors
+
+2002-06-08 Martin Baulig <martin@gnome.org>
+
+ * expression.cs (Unary.TryReduceNegative): Added support for
+ ULongConstants.
+
+2002-06-08 Martin Baulig <martin@gnome.org>
+
+ * enum.cs (Enum.LookupEnumValue): Don't report an error if the
+ name can't be found in the `defined_names' - the caller will do a
+ MemberLookup in this case and thus find methods in System.Enum
+ such as Enum.IsDefined().
+
+2002-06-08 Martin Baulig <martin@gnome.org>
+
+ * enum.cs (Enum.ChangeEnumType): This is a custom version of
+ Convert.ChangeType() which works with TypeBuilder created types.
+ (Enum.LookupEnumValue, Enum.Define): Use it here.
+
+ * class.cs (TypeContainer.RegisterRequiredImplementations): Added
+ `TypeBuilder.BaseType != null' check.
+ (TypeContainer.FindMembers): Only lookup parent members if we
+ actually have a parent.
+ (Method.EmitDestructor): Added `ec.ContainerType.BaseType != null' check.
+ (ConstructorInitializer.Resolve): Likewise.
+
+ * interface.cs (Interface.FindMembers): Added
+ `TypeBuilder.BaseType != null' check.
+
+ * rootcontext.cs (RootContext.ResolveCore): Added
+ "System.Runtime.CompilerServices.IndexerNameAttribute" to
+ classes_second_stage.
+
+ * typemanager.cs (TypeManager.InitCoreTypes): Don't initialize
+ debug_type and trace_type when compiling with --nostdlib.
+
+2002-06-07 Martin Baulig <martin@gnome.org>
+
+ * class.cs (TypeContainer): Added `have_nonstatic_fields' field.
+ (AddField): Set it to true when adding a non-static field.
+ (DefineType): Use `have_nonstatic_fields' to find out whether we
+ have non-static fields, not `Fields != null'.
+
+2002-06-02 Miguel de Icaza <miguel@ximian.com>
+
+ * ecore.cs (SimpleNameResolve): Removed simple bug (we were
+ dereferencing a null on the static-field code path)
+
+2002-05-30 Martin Baulig <martin@gnome.org>
+
+ * codegen.cs (InitMonoSymbolWriter): Added `string[] args' argument
+ to take command line arguments. Use reflection to call the new
+ custom `Initialize' function on the symbol writer and pass it the
+ command line arguments.
+
+ * driver.cs (--debug-args): New command line argument to pass command
+ line arguments to the symbol writer.
+
+2002-05-28 Miguel de Icaza <miguel@ximian.com>
+
+ * assign.cs (DoResolve): Forgot to do the implicit conversion to
+ the target type for indexers and properties. Thanks to Joe for
+ catching this.
+
+2002-05-27 Miguel de Icaza <miguel@ximian.com>
+
+ * typemanager.cs (MethodFlags): returns the method flags
+ (Obsolete/ShouldIgnore) that control warning emission and whether
+ the invocation should be made, or ignored.
+
+ * expression.cs (Invocation.Emit): Remove previous hack, we should
+ not do this on matching a base type, we should do this based on an attribute
+
+ Only emit calls to System.Diagnostics.Debug and
+ System.Diagnostics.Trace if the TRACE and DEBUG defines are passed
+ on the command line.
+
+ * rootcontext.cs: Global settings for tracing and debugging.
+
+ * cs-tokenizer.cs (define): New utility function to track
+ defines. Set the global settings for TRACE and DEBUG if found.
+
+2002-05-25 Ravi Pratap <ravi@ximian.com>
+
+ * interface.cs (Populate*): Pass in the TypeContainer as well as
+ the DeclSpace as parameters so that we can create EmitContexts and
+ then use that to apply attributes etc.
+
+ (PopulateMethod, PopulateEvent, PopulateProperty)
+ (PopulateIndexer): Apply attributes everywhere.
+
+ * attribute.cs (CheckAttribute): Include InterfaceMethod, InterfaceEvent
+ etc.
+
+ (ApplyAttributes): Update accordingly.
+
+ We now apply interface attributes for all members too.
+
+2002-05-26 Miguel de Icaza <miguel@ximian.com>
+
+ * class.cs (Indexer.Define); Correctly check if we are explicit
+ implementation (instead of checking the Name for a ".", we
+ directly look up if the InterfaceType was specified).
+
+ Delay the creation of the PropertyBuilder.
+
+ Only create the PropertyBuilder if we are not an explicit
+ interface implementation. This means that explicit interface
+ implementation members do not participate in regular function
+ lookups, and hence fixes another major ambiguity problem in
+ overload resolution (that was the visible effect).
+
+ (DefineMethod): Return whether we are doing an interface
+ implementation.
+
+ * typemanager.cs: Temporary hack until we get attributes in
+ interfaces (Ravi is working on that) and we get IndexerName
+ support in interfaces.
+
+ * interface.cs: Register the indexers as properties.
+
+ * attribute.cs (Attribute.Resolve): Catch the error, and emit a
+ warning, I have verified that this is a bug in the .NET runtime
+ (JavaScript suffers of the same problem).
+
+ * typemanager.cs (MemberLookup): When looking up members for
+ interfaces, the parent of an interface is the implicit
+ System.Object (so we succeed in searches of Object methods in an
+ interface method invocation. Example: IEnumerable x; x.ToString
+ ())
+
+2002-05-25 Miguel de Icaza <miguel@ximian.com>
+
+ * class.cs (Event): Events should also register if they do
+ implement the methods that an interface requires.
+
+ * typemanager.cs (MemberLookup); use the new GetInterfaces
+ method.
+
+ (GetInterfaces): The code used to lookup interfaces for a type is
+ used in more than one place, factor it here.
+
+ * driver.cs: Track the errors at the bottom of the file, we kept
+ on going.
+
+ * delegate.cs (NewDelegate.Emit): We have to emit a null as the
+ instance if the method we are calling is static!
+
+2002-05-24 Miguel de Icaza <miguel@ximian.com>
+
+ * attribute.cs (ApplyAttributes): Make this function filter out
+ the IndexerName attribute (as that attribute in reality is never
+ applied) and return the string constant for the IndexerName
+ attribute.
+
+ * class.cs (TypeContainer.Emit): Validate that all the indexers
+ have the same IndexerName attribute, and if so, set the
+ DefaultName attribute on the class.
+
+ * typemanager.cs: The return value might contain other stuff (not
+ only methods). For instance, consider a method with an "Item"
+ property and an Item method.
+
+ * class.cs: If there is a problem with the parameter types,
+ return.
+
+2002-05-24 Ravi Pratap <ravi@ximian.com>
+
+ * ecore.cs (ImplicitConversionExists): Wrapper function which also
+ looks at user defined conversion after making a call to
+ StandardConversionExists - we need this for overload resolution.
+
+ * expression.cs : Update accordingly the various method calls.
+
+ This fixes 2 bugs filed against implicit user defined conversions
+
+2002-05-22 Miguel de Icaza <miguel@ximian.com>
+
+ * statement.cs: Track the result of the assignment.
+
+2002-05-21 Miguel de Icaza <miguel@ximian.com>
+
+ * expression.cs (MemberAccess): Improved error reporting for
+ inaccessible members.
+
+2002-05-22 Martin Baulig <martin@gnome.org>
+
+ * makefile (mcs-mono2.exe): New target. This is mcs compiled with
+ itself with debugging support.
+
+2002-05-22 Martin Baulig <martin@gnome.org>
+
+ * typemanager.cs ("System.Runtime.InteropServices.StructLayoutAttribute"):
+ Removed, this isn't needed anymore.
+
+2002-05-20 Martin Baulig <martin@gnome.org>
+
+ * typemanager.cs (InitEnumUnderlyingTypes): "System.Char" can't
+ be underlying type for an enum.
+
+2002-05-20 Miguel de Icaza <miguel@ximian.com>
+
+ * typemanager.cs (InitEnumUnderlyingTypes): New helper function
+ that splits out the loading of just the core types.
+
+ * rootcontext.cs (ResolveCore): Split the struct resolution in
+ two, so we can load the enumeration underlying types before any
+ enums are used.
+
+ * expression.cs (Is): Bandaid until we fix properly Switch (see
+ bug #24985 for details).
+
+ * typemanager.cs (ImplementsInterface): The hashtable will contain
+ a null if there are no interfaces implemented.
+
+2002-05-18 Miguel de Icaza <miguel@ximian.com>
+
+ * cs-parser.jay (indexer_declarator): It is fine to have array
+ parameters
+
+2002-05-17 Miguel de Icaza <miguel@ximian.com>
+
+ * typemanager.cs: (RegisterBuilder): New function used to register
+ TypeBuilders that implement interfaces. Since
+ TypeBuilder.GetInterfaces (as usual) does not work with lame
+ Reflection.Emit.
+ (AddUserType): register interfaces.
+
+ (ImplementsInterface): Use the builder_to_ifaces hash if we are
+ dealing with TypeBuilder. Also, arrays are showing up as
+ SymbolTypes, which are not TypeBuilders, but whose GetInterfaces
+ methods can not be invoked on them!
+
+ * ecore.cs (ExplicitReferenceConversionExists): Made public.
+ (ImplicitReferenceConversionExists): Split out from
+ StandardConversionExists.
+
+ * expression.cs (As): We were only implementing one of the three
+ cases for the as operator. We now implement them all.
+ (Is): Implement the various other cases for Is as well.
+
+ * typemanager.cs (CACHE): New define used to control if we want or
+ not the FindMembers cache. Seems to have a negative impact on
+ performance currently
+
+ (MemberLookup): Nested types have full acess to
+ enclosing type members
+
+ Remove code that coped with instance/static returns for events, we
+ now catch this in RealFindMembers.
+
+ (RealFindMembers): only perform static lookup if the instance
+ lookup did not return a type or an event.
+
+2002-05-17 Miguel de Icaza <miguel@ximian.com>
+
+ * assign.cs (CompoundAssign): We pass more semantic information
+ now to Compound Assignments than we did before: now we have all
+ the information at hand, and now we resolve the target *before* we
+ do the expression expansion, which allows the "CacheValue" method
+ to have the effect we intended (before, a [x] += 1 would generate
+ two differen ArrayAccess expressions from the ElementAccess,
+ during the resolution process).
+
+ (CompoundAssign.DoResolve): Resolve target and original_source here.
+
+2002-05-16 Miguel de Icaza <miguel@ximian.com>
+
+ * expression.cs (ArrayAccess): dropped debugging information.
+
+ * typemanager.cs: Small bug fix: I was always returning i_members,
+ instead of one of i_members or s_members (depending on which had
+ the content).
+
+ * assign.cs (IAssignMethod.CacheTemporaries): New method. This
+ method is invoked before any code generation takes place, and it
+ is a mechanism to inform that the expression will be invoked more
+ than once, and that the method should use temporary values to
+ avoid having side effects
+
+ (Assign.Emit): Call CacheTemporaries in the IAssignMethod.
+
+ * ecore.cs (Expression.CacheTemporaries): Provide empty default
+ implementation.
+
+ * expression.cs (Indirection, ArrayAccess): Add support for
+ CacheTemporaries in these two bad boys.
+
+ * ecore.cs (LoadFromPtr): figure out on our own if we need to use
+ ldobj or ldind_ref.
+ (StoreFromPtr): Handle stobj as well.
+
+ * expression.cs (UnaryMutator): Share more code.
+
+ * typemanager.cs (FindMembers): Thanks to Paolo for tracking this
+ down: I was not tracking the Filter function as well, which
+ was affecting the results of the cache.
+
+2002-05-15 Miguel de Icaza <miguel@ximian.com>
+
+ * attribute.cs: Remove the hack to handle the CharSet property on
+ StructLayouts.
+
+2002-05-14 Miguel de Icaza <miguel@ximian.com>
+
+ * attribute.cs (DoResolve): More uglyness, we now only try to
+ resolve the attribute partially, to extract the CharSet
+ information (only if we are a StructLayout attribute). Otherwise
+
+ (GetExtraTypeInfo): Add some code to conditionally kill in the
+ future this. I am more and more convinced that the .NET
+ framework has special code to handle the attribute setting on
+ certain elements.
+
+ * expression.cs (IsParamsMethodApplicable): Revert my previous
+ foreach change here, it was wrong.
+
+2002-05-13 Miguel de Icaza <miguel@ximian.com>
+
+ * cs-tokenizer.cs: (pp_primary): Eat the ')' at the end.
+ (pp_expr): do not abort on unknown input, just return.
+ (eval): abort if there are pending chars.
+
+ * attribute.cs (Attribute.Resolve): Positional parameters are
+ optional. Deal with that case.
+
+ * class.cs (DefineType): Call Attribute.GetExtraTypeInfo to fetch
+ the Ansi/Unicode/Auto information for the type.
+
+ (TypeContainer.DefineType): instantiate the EmitContext here, as
+ we will be using it during the type definition (to resolve
+ attributes) and during the emit phase.
+
+ * attribute.cs (Attribute.GetExtraTypeInfo): This routine is used
+ to pull type information out of the attributes
+
+ (Attribute.Resolve): track the constructor builder, and allow for
+ multiple invocations (structs and classes will use this).
+
+ * ecore.cs (MemberLookupFinal): new version with all the
+ parameters customizable.
+
+ * expression.cs (New.DoResolve): Use MemberLookupFinal to locate
+ constructors. Return if the result value is null (as the error
+ would have been flagged already by MemberLookupFinal)
+
+ Do not allow instances of abstract classes or interfaces to be
+ created.
+
+ * class.cs: (MethodSignature.InheritableMemberSignatureCompare):
+ We have to compare the assembly property here when dealing with
+ FamANDAssem and Assembly access modifiers, because we might be
+ creating an assembly from *modules* (that means that we are not
+ getting TypeBuilders for types defined in other modules that are
+ part of this assembly).
+
+ (Method.Emit): If the method is marked abstract and has a body,
+ emit an error.
+
+ (TypeContainer.DefineMembers): If both the defined member and the
+ parent name match are methods, then do not emit any warnings: let
+ the Method.Define routine take care of flagging warnings. But if
+ there is a mismatch (method overrides something else, or method is
+ overriwritten by something, then emit warning).
+
+ (MethodSignature.MemberSignatureCompare): If the sig.ret_type is
+ set to null, this means `do not check for the return type on the
+ signature'.
+
+ (Method.Define): set the return type for the method signature to
+ null, so that we get methods with the same name and parameters and
+ different return types. This is used to flag warning 114 (you are
+ hiding a method, and you probably want to use the new/override
+ keywords instead).
+
+ * typemanager.cs (MemberLookup): Implemented proper access
+ control, closing a long standing set of bug reports. The problem
+ was that the Framework only has two bits: Public and NonPublic,
+ and NonPublic includes private and protected methods, but we need
+ to enforce the FamANDAssem, FamOrAssem and Family.
+
+2002-05-11 Miguel de Icaza <miguel@ximian.com>
+
+ * statement.cs (GotoCase): Return true: Ammounts to giving up
+ knowledge on whether we return or not, and letting the other case
+ be responsible for it.
+
+2002-05-10 Miguel de Icaza <miguel@ximian.com>
+
+ * driver.cs: Do not load directories for each file processed, only
+ do it if there is a pattern.
+
+ * ecore.cs: Report readonly assigns here as well, as we might have
+ been resolved only by MemberAccess.
+
+ (SimpleName.SimpleNameResolve): Also be useful for LValue
+ resolution. We need this to propagate assign to local readonly variables
+
+ * typemanager.cs: Use a ptrhashtable for the criteria, because we
+ do not want to reuse potential criteria memory.
+
+ * class.cs (MyEventBuilder): Set reflected_type;
+
+ * ecore.cs (Constantify): Added support for constifying bools.
+
+ (RootContext.LookupType): Added a cache for values looked up in
+ the declaration space.
+
+ * typemanager.cs (FindMembers): Now is a front-end to
+ RealFindMembers, and provides a two-level hashtable-based cache to
+ the request.
+
+ 15% performance improvement: from 22.5 to 19.2 seconds.
+
+ * expression.cs (IsParamsMethodApplicable): use foreach.
+ (Invocation.DoResolve): ditto.
+ (New.DoResolve): ditto.
+ (ArrayCreation.DoResolve): ditto.
+
+ * ecore.cs (FindMostEncompassingType): use foreach.
+
+ * delegate.cs (NewDelegate.DoResolve): Use foreach
+
+ * ecore.cs (Expression.FindMostSpecificSource): Use foreach.
+ (RemoveMethods): use foreach.
+
+ * expression.cs (Invocation.MakeUnionSet): Optimization: Use two
+ nested foreach statements instead of for, and also break out of
+ the inner loop once a match is found.
+
+ (Invocation.OverloadResolve): Use foreach, simplify the code.
+
+2002-05-08 Miguel de Icaza <miguel@ximian.com>
+
+ * cfold.cs (BinaryFold): During an enumeration evaluation context,
+ we actually unwrap the expression to allow for extra information
+ to be extracted.
+
+ * expression.cs: Use Shr_Un on unsigned operations.
+
+2002-05-08 Ravi Pratap <ravi@ximian.com>
+
+ * ecore.cs (FindMostEncompass*): Fix trivial bug where the set of
+ applicable operators was not being considered correctly. This closes
+ the bug Miguel reported.
+
+Wed May 8 16:40:50 CEST 2002 Paolo Molaro <lupus@ximian.com>
+
+ * attribute.cs: check that the type derives from System.Attribute
+ and report the correct error in that case (moved the duplicate code to
+ its own method, too).
+
+Wed May 8 11:50:31 CEST 2002 Paolo Molaro <lupus@ximian.com>
+
+ * attribute.cs: lookup attribute type name as the spec says: first the
+ bare attribute name and then name + "Attribute" (nant compiles with
+ mcs after this fix).
+
+2002-05-07 Miguel de Icaza <miguel@ximian.com>
+
+ * expression.cs (Unary.TryReduceNegative): Ah! Tricky! Tricky!
+ Because of the way we parse things, we should try to see if a
+ UIntConstant can fit in an integer.
+
+2002-05-07 Ravi Pratap <ravi@ximian.com>
+
+ * ecore.cs (GetConversionOperators): Do not pick up op_True operators
+ when we are in an explicit context.
+
+ (ConvertReferenceExplicit): When converting from Iface type S to Class
+ T make sure the rules are implemented as an OR.
+
+ * parameter.cs (ParameterType): Make it a property for now although the
+ purpose really isn't anything immediate.
+
+ * expression.cs (Is*Applicable): Do better checking on the parameter type
+ of a ref/out parameter. The ones from the system assemblies are already
+ marked with the correct type so we don't need to do any correction.
+
+ * ecore.cs (StandardConversionExists): Conversion from Interface types to
+ the object type is standard too so include that.
+
+2002-05-06 Miguel de Icaza <miguel@ximian.com>
+
+ * ecore.cs (StandardConversionExists): Augment with missing code:
+ deal with IntConstant, LongConstants and Enumerations.
+
+ * assign.cs: Report the error, instead of failing silently
+
+ * rootcontext.cs (AddGlobalAttributes): Track attributes on the
+ typecontainer that they are declared, because the
+ typecontainer/namespace will have the list of using clauses that
+ need to be applied.
+
+ Assembly Attributes were escaping the normal registration
+ mechanism.
+
+ (EmitCode): Apply attributes within an EmitContext that represents
+ the container they were declared on.
+
+ * cs-parser.jay: Track bases for structs. How did I get this wrong?
+
+2002-05-06 Ravi Pratap <ravi@ximian.com>
+
+ * ecore.cs (FindMostEncompassingType, FindMostEncompassedType):
+ Revamp completely - make much cleaner as we now operate only
+ on a set of Types.
+
+ (FindMostSpecificSource, FindMostSpecificTarget): New methods
+ to implement the logic detailed in the spec more correctly.
+
+ (UserDefinedConversion): Update accordingly.
+
+2002-05-06 Miguel de Icaza <miguel@ximian.com>
+
+ * statement.cs: Return flow analysis information up.
+
+ * cs-tokenizer.cs (adjust_real): Share code between LITERAL_DOUBLE
+ and the default.
+
+ (token): Do not consume an extra character before calling
+ decimal_digits.
+
+2002-05-06 Piers Haken <piersh@friskit.com>
+
+ * cs-parser.jay: add 'override' attribute to System.Object.Finalize
+
+2002-05-06 Miguel de Icaza <miguel@ximian.com>
+
+ * class.cs (Constructor.Emit): Set the IsStatic flag in the
+ EmitContext during the instance constructor initializer
+ resolution, to stop access to instance variables.
+
+ This is mandated by the spec, last paragraph of the `constructor
+ initializers' section.
+
2002-05-05 Miguel de Icaza <miguel@ximian.com>
* cs-parser.jay, class.cs (Accessor): new class used to represent
projects / mono.git / blobdiff