X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;ds=sidebyside;f=mcs%2Fmcs%2FChangeLog;h=ebf45efede77196be8e10225c4f93ed82f9f90dc;hb=92caceea59cdc94850989351ebc35aab501c29fa;hp=ecbe75c621eda6c712acaa06609bd6fa05de4a73;hpb=b2febae24cd8336761672aa27ae901647b4bc378;p=mono.git diff --git a/mcs/mcs/ChangeLog b/mcs/mcs/ChangeLog index ecbe75c621e..ebf45efede7 100755 --- a/mcs/mcs/ChangeLog +++ b/mcs/mcs/ChangeLog @@ -1,5 +1,578 @@ +2002-06-27 Martin Baulig + + * 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 + + * 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 + + * 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 + + * 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 + + * 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 + + * 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 + + * typemanager.cs: make ExpandInterfaces() slip duplicated interfaces. + +2002-06-20 Miguel de Icaza + + * 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 + + * typemanager.cs (TypeManager.EnumToUnderlying): It's now safe to call this function + on System.Enum. + +2002-06-21 Martin Baulig + + * 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 + + * 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 + + * 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 + + * 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 + + * 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 + + * ecore.cs: don't use ldlen with System.Array. + +Wed Jun 19 20:57:40 CEST 2002 Paolo Molaro + + * ecore.cs: stobj requires a type argument. Handle indirect stores on enums. + +Wed Jun 19 20:17:59 CEST 2002 Paolo Molaro + + * 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 + + * 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 + + * rootcontext.cs: added a couple more types needed to bootstrap. + +2002-06-17 Miguel de Icaza + + * 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 + * changed namespace.cs to use "GenericParser.error(...)" instead of "CSharpParser.error(...)" + +2002-06-14 Rachel Hestilow + + * expression.cs (Unary.ResolveOperator): Use TypeManager + to resolve the type. + +2002-06-13 Ravi Pratap + + * 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 + + * typemanager.cs (TypeManager.VerifyUnManaged): Allow + address-of operator on both value types and pointers. + +2002-06-10 Martin Baulig + + * 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 + + * 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 + + * expression.cs (Cast.TryReduce): Added support for consts. + +2002-06-08 Ravi Pratap + + * 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 + + * expression.cs (Unary.TryReduceNegative): Added support for + ULongConstants. + +2002-06-08 Martin Baulig + + * 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 + + * 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 + + * 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 + + * ecore.cs (SimpleNameResolve): Removed simple bug (we were + dereferencing a null on the static-field code path) + +2002-05-30 Martin Baulig + + * 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 + + * 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 + + * 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 + + * 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 + + * 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 + + * 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 + + * 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 + + * 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 + + * statement.cs: Track the result of the assignment. + +2002-05-21 Miguel de Icaza + + * expression.cs (MemberAccess): Improved error reporting for + inaccessible members. + +2002-05-22 Martin Baulig + + * makefile (mcs-mono2.exe): New target. This is mcs compiled with + itself with debugging support. + +2002-05-22 Martin Baulig + + * typemanager.cs ("System.Runtime.InteropServices.StructLayoutAttribute"): + Removed, this isn't needed anymore. + +2002-05-20 Martin Baulig + + * typemanager.cs (InitEnumUnderlyingTypes): "System.Char" can't + be underlying type for an enum. + +2002-05-20 Miguel de Icaza + + * 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 + + * cs-parser.jay (indexer_declarator): It is fine to have array + parameters + +2002-05-17 Miguel de Icaza + + * 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 + + * 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 + + * 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 + + * attribute.cs: Remove the hack to handle the CharSet property on + StructLayouts. + +2002-05-14 Miguel de Icaza + + * 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 + * 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.