X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2FChangeLog;h=57f11e72329fb39495d5025037383b0292ce5d16;hb=55a71babd783331b36e559825ec01b9f61b07983;hp=5b9bbe960b96b195216261e7664b5a3220fc42ad;hpb=9668c168547a90d220a50b2797b5d745b4bd8cc9;p=mono.git diff --git a/mcs/mcs/ChangeLog b/mcs/mcs/ChangeLog index 5b9bbe960b9..57f11e72329 100755 --- a/mcs/mcs/ChangeLog +++ b/mcs/mcs/ChangeLog @@ -1,9 +1,819 @@ -2004-09-14 Martin Baulig +2004-11-05 Miguel de Icaza + + * Indexers were using the ShortName when defining themselves, + causing a regression in the compiler bootstrap when applying the + patch from 2004-11-02 (first part), now they use their full name + and the bug is gone. + +2004-11-04 Zoltan Varga + + * driver.cs: Strip the path from the names of embedded resources. Fixes + #68519. + +2004-11-04 Raja R Harinath + + Fix error message regression: cs0104-2.cs. + * namespace.cs (NamespaceEntry.Lookup): Remove 'silent' flag. + (AliasEntry.Resolve): Update. + * rootcontext.cs (RootContext.NamespaceLookup): Update. Remove + 'silent' flag. + (RootContext.LookupType): Update. + +2004-11-03 Carlos Alberto Cortez + + * cs-parser.jay: Add support for handling accessor modifiers + * class: Add support port accessor modifiers and error checking, + define PropertyMethod.Define as virtual (not abstract anymore) + * ecore.cs: Add checking for proeprties access with access modifiers + * iterators.cs: Modify Accessor constructor call based in the modified + constructor +2004-11-02 Ben Maurer + + * expression.cs (StringConcat): Handle being called twice, + as when we have a concat in a field init with more than two + ctors in the class + +2004-11-02 Miguel de Icaza + + * class.cs (Event.Define, Indexer.Define, Property.Define): Do not + special case explicit implementations, we should always produce + the .property or .event declaration. + + * decl.cs (MemberName): Renamed GetFullName to GetPartialName + since it will not return correct data if people use this + unresolved in the presence of using statements (see test-313). + + * class.cs (MethodData.Define): If we are an explicit interface + implementation, set the method name to the full name of the + interface plus the name of the method. + + Notice that using the method.MethodName.GetFullName() does not + work, as it will only contain the name as declared on the source + file (it can be a shorthand in the presence of using statements) + and not the fully qualifed type name, for example: + + using System; + + class D : ICloneable { + object ICloneable.Clone () { + } + } + + Would produce a method called `ICloneable.Clone' instead of + `System.ICloneable.Clone'. + + * namespace.cs (Alias.Resolve): Use GetPartialName. + +2004-11-01 Marek Safar + + * cs-parser.jay: Add error 1055 report. + +2004-11-01 Miguel de Icaza + + * assign.cs (Assign.DoResolve): Only do the transform of + assignment into a New if the types are compatible, if not, fall + through and let the implicit code deal with the errors and with + the necessary conversions. + +2004-11-01 Marek Safar + + * cs-parser.jay: Add error 1031 report. + + * cs-tokenizer.cs: Add location for error 1038. + +2004-10-31 Marek Safar + + * cs-parser.jay: Add error 1016 report. + +2004-10-31 Marek Safar + + * cs-parser.jay: Add errors 1575,1611 report. + +2004-10-31 Marek Safar + + * cs-parser.jay: Add error 1001 report. + +2004-10-31 Marek Safar + + Fix #68850 + * attribute.cs (GetMarshal): Add method argument for + caller identification. + + * class.cs, codegen.cs, enum.cs, parameter.cs: Added + agument for GetMarshal and RuntimeMissingSupport. + +2004-10-31 Marek Safar + + * attribute.cs (ExtractSecurityPermissionSet): Removed + TypeManager.code_access_permission_type. + + * typemanager.cs: Removed TypeManager.code_access_permission_type. + +2004-10-27 Miguel de Icaza + + * expression.cs (LocalVariableReference.DoResolveLValue): Check + for obsolete use of a variable here. Fixes regression on errors + cs0619-25 and cs0619-26. + +2004-10-27 Marek Safar + + Fix #62358, implemented security attribute encoding. + + * attribute.cs (Attribute.CheckSecurityActionValididy): New method. + Tests permitted SecurityAction for assembly or other types. + (Assembly.ExtractSecurityPermissionSet): New method. Transforms + data from SecurityPermissionAttribute to PermisionSet class. + + * class.cs (ApplyAttributeBuilder): Added special handling + for System.Security.Permissions.SecurityAttribute based types. + + * codegen.cs (AssemblyClass.ApplyAttributeBuilder): Added + special handling for System.Security.Permissions.SecurityAttribute + based types. + + * enum.cs (ApplyAttributeBuilder): Added special handling + for System.Security.Permissions.SecurityAttribute based types. + + * parameter.cs (ApplyAttributeBuilder): Added special handling + for System.Security.Permissions.SecurityAttribute based types. + + * rootcontext.cs: Next 2 core types. + + * typemanager.cs (TypeManager.security_permission_attr_type): + Built in type for the SecurityPermission Attribute. + (code_access_permission_type): Build in type. + +2004-10-17 Miguel de Icaza + + * expression.cs (LocalVariableReference.DoResolveBase, Emit): + Remove the tests for `ec.RemapToProxy' from here, and encapsulate + all of this information into + EmitContext.EmitCapturedVariableInstance. + + * codegen.cs (EmitCapturedVariableInstance): move here the + funcionality of emitting an ldarg.0 in the presence of a + remapping. This centralizes the instance emit code. + + (EmitContext.EmitThis): If the ScopeInfo contains a THIS field, + then emit a load of this: it means that we have reached the + topmost ScopeInfo: the one that contains the pointer to the + instance of the class hosting the anonymous method. + + * anonymous.cs (AddField, HaveCapturedFields): Propagate field + captures to the topmost CaptureContext. + +2004-10-12 Miguel de Icaza + + * expression.cs (LocalVariableReference): Move the knowledge about + the iterators into codegen's EmitCapturedVariableInstance. + +2004-10-11 Miguel de Icaza + + * codegen.cs (EmitContext.ResolveTopBlock): Emit a 1643 when not + all code paths return a value from an anonymous method (it is the + same as the 161 error, but for anonymous methods). + +2004-10-08 Miguel de Icaza + + The introduction of anonymous methods in the compiler changed + various ways of doing things in the compiler. The most + significant one is the hard split between the resolution phase + and the emission phases of the compiler. + + For instance, routines that referenced local variables no + longer can safely create temporary variables during the + resolution phase: they must do so from the emission phase, + since the variable might have been "captured", hence access to + it can not be done with the local-variable operations from the runtime. + + * statement.cs + + (Block.Flags): New flag `IsTopLevel' to indicate that this block + is a toplevel block. + + (ToplevelBlock): A new kind of Block, these are the blocks that + are created by the parser for all toplevel method bodies. These + include methods, accessors and anonymous methods. + + These contain some extra information not found in regular blocks: + A pointer to an optional CaptureContext (for tracking captured + local variables and parameters). A pointer to the parent + ToplevelBlock. + + (Return.Resolve): Catch missmatches when returning a value from an + anonymous method (error 1662). + Invoke NeedReturnLabel from the Resolve phase instead of the emit + phase. + + (Break.Resolve): ditto. + + (SwitchLabel): instead of defining the labels during the + resolution phase, we now turned the public ILLabel and ILLabelCode + labels into methods called GetILLabelCode() and GetILLabel() that + only define the label during the Emit phase. + + (GotoCase): Track the SwitchLabel instead of the computed label + (its contained therein). Emit the code by using + SwitchLabel.GetILLabelCode (). + + (LocalInfo.Flags.Captured): A new flag has been introduce to track + whether the Local has been captured or not. + + (LocalInfo.IsCaptured): New property, used to tell whether the + local has been captured. + + * anonymous.cs: Vastly updated to contain the anonymous method + support. + + The main classes here are: CaptureContext which tracks any + captured information for a toplevel block and ScopeInfo used to + track the activation frames for various local variables. + + Each toplevel block has an optional capture context associated + with it. When a method contains an anonymous method both the + toplevel method and the anonymous method will create a capture + context. When variables or parameters are captured, they are + recorded on the CaptureContext that owns them, for example: + + void Demo () { + int a; + MyDelegate d = delegate { + a = 1; + } + } + + Here `a' will be recorded as captured on the toplevel + CapturedContext, the inner captured context will not have anything + (it will only have data if local variables or parameters from it + are captured in a nested anonymous method. + + The ScopeInfo is used to track the activation frames for local + variables, for example: + + for (int i = 0; i < 10; i++) + for (int j = 0; j < 10; j++){ + MyDelegate d = delegate { + call (i, j); + } + } + + At runtime this captures a single captured variable `i', but it + captures 10 different versions of the variable `j'. The variable + `i' will be recorded on the toplevel ScopeInfo, while `j' will be + recorded on a child. + + The toplevel ScopeInfo will also track information like the `this' + pointer if instance variables were referenced (this is necessary + as the anonymous method lives inside a nested class in the host + type of the method). + + (AnonymousMethod): Expanded to track the Toplevel, implement + `AnonymousMethod.Compatible' to tell whether an anonymous method + can be converted to a target delegate type. + + The routine now also produces the anonymous method content + + (AnonymousDelegate): A helper class that derives from + DelegateCreation, this is used to generate the code necessary to + produce the delegate for the anonymous method that was created. + + * assign.cs: API adjustments for new changes in + Convert.ImplicitStandardConversionExists. + + * class.cs: Adjustments to cope with the fact that now toplevel + blocks are of type `ToplevelBlock'. + + * cs-parser.jay: Now we produce ToplevelBlocks for toplevel blocks + insteda of standard blocks. + + Flag errors if params arguments are passed to anonymous methods. + + * codegen.cs (EmitContext): Replace `InAnonymousMethod' with + `CurrentAnonymousMethod' which points to the current Anonymous + Method. The variable points to the AnonymousMethod class that + holds the code being compiled. It is set in the new EmitContext + created for the anonymous method. + + (EmitContext.Phase): Introduce a variable and an enumeration to + assist in enforcing some rules about when and where we are allowed + to invoke certain methods (EmitContext.NeedsReturnLabel is the + only one that enfonces this right now). + + (EmitContext.HaveCaptureInfo): new helper method that returns + whether we have a CapturedContext initialized. + + (EmitContext.CaptureVariable): New method used to register that a + LocalInfo must be flagged for capturing. + + (EmitContext.CapturedParameter): New method used to register that a + parameters must be flagged for capturing. + + (EmitContext.CapturedField): New method used to register that a + field must be flagged for capturing. + + (EmitContext.HaveCapturedVariables, + EmitContext.HaveCapturedFields): Return whether there are captured + variables or fields. + + (EmitContext.EmitMethodHostInstance): This is used to emit the + instance for the anonymous method. The instance might be null + (static methods), this (for anonymous methods that capture nothing + and happen to live side-by-side with the current method body) or a + more complicated expression if the method has a CaptureContext. + + (EmitContext.EmitTopBlock): Routine that drives the emission of + code: it will first resolve the top block, then emit any metadata + and then emit the code. The split is done so that we can extract + any anonymous methods and flag any captured variables/parameters. + + (EmitContext.ResolveTopBlock): Triggers the resolution phase, + during this phase, the ILGenerator should not be used as labels + and local variables declared here might not be accessible to any + code that is part of an anonymous method. + + Exceptions to this include the temporary variables that are + created by some statements internally for holding temporary + variables. + + (EmitContext.EmitMeta): New routine, in charge of emitting all the + metadata for a cb + + (EmitContext.TemporaryReturn): This method is typically called + from the Emit phase, and its the only place where we allow the + ReturnLabel to be defined other than the EmitMeta. The reason is + that otherwise we would have to duplicate a lot of logic in the + Resolve phases of various methods that today is on the Emit + phase. + + (EmitContext.NeedReturnLabel): This no longer creates the label, + as the ILGenerator is not valid during the resolve phase. + + (EmitContext.EmitThis): Extended the knowledge in this class to + work in anonymous methods in addition to iterators. + + (EmitContext.EmitCapturedVariableInstance): This emits whatever + code is necessary on the stack to access the instance to a local + variable (the variable will be accessed as a field). + + (EmitContext.EmitParameter, EmitContext.EmitAssignParameter, + EmitContext.EmitAddressOfParameter): Routines to support + parameters (not completed at this point). + + Removals: Removed RemapLocal and RemapLocalLValue. We probably + will also remove the parameters. + + * convert.cs (Convert): Define a `ConstantEC' which points to a + null. This is just to prefity some code that uses + ImplicitStandardConversion code and do not have an EmitContext + handy. + + The idea is to flag explicitly that at that point in time, it is + known that the conversion will not trigger the delegate checking + code in implicit conversions (which requires a valid + EmitContext). + + Everywhere: pass new EmitContext parameter since + ImplicitStandardConversionExists now requires it to check for + anonymous method conversions. + + (Convert.ImplicitStandardConversionExists): If the type of an + expression is the anonymous_method_type, and the type is a + delegate, we invoke the AnonymousMethod.Compatible method to check + whether an implicit conversion is possible. + + (Convert.ImplicitConversionStandard): Only do implicit method + group conversions if the language level is not ISO_1. + + * delegate.cs (Delegate.GetInvokeMethod): Common method to get the + MethodInfo for the Invoke method. used by Delegate and + AnonymousDelegate. + + * expression.cs (Binary.DoNumericPromotions): only allow anonymous + method conversions if the target type is a delegate. + + Removed extra debugging nops. + + (LocalVariableReference): Turn the `local_info' into a public + field. + + Add `prepared' field, the same hack used for FieldExprs to cope + with composed assignments, as Local variables do not necessarily + operate purely on the stack as they used to: they can be captured + fields. + + Add `temp' for a temporary result, like fields. + + Refactor DoResolve and DoResolveLValue into DoResolveBase. + + It now copes with Local variables that are captured and emits the + proper instance variable to load it from a field in the captured + case. + + (ParameterReference.DoResolveBase): During the resolve phase, + capture parameters if we are in an anonymous method. + + (ParameterReference.Emit, ParameterReference.AddressOf): If in an + anonymous method, use the EmitContext helper routines to emit the + parameter reference. + + * iterators.cs: Set RemapToProxy to true/false during the + EmitDispose class. + + * parameters.cs (GetParameterByName): New helper method. + + * typemanager.cs (anonymous_method_type) a new type that + represents an anonyous method. This is always an internal type, + used as a fencepost to test against the anonymous-methodness of an + expression. + +2004-10-24 Marek Safar + + Fixed bugs #63705, #67130 + * decl.cs (MemberCache.MemberCache): Add parameter to distinguish + imported and defined interfaces. + (CacheEntry, EntryType): Changed to protected internal. + + * class.cs (TypeContainer.DoDefineMembers): Setup cache for + interfaces too. + + * typemanager.cs (LookupInterfaceContainer): New method. + Fills member container from base interfaces. + +2004-10-20 Marek Safar + + * class.cs (MethodCore.CheckBase): Add errors 505, 533, 544, + 561 report. + (PropertyBase.FindOutParentMethod): Add errors 545, 546 report. + +2004-10-18 Martin Baulig Merged latest changes into gmcs. Please keep this comment in here, it makes it easier for me to see what changed in MCS since the last time I merged. +2004-10-18 Martin Baulig + + * statement.cs (Fixed.Resolve): Don't access the TypeExpr's + `Type' directly, but call ResolveType() on it. + (Catch.Resolve): Likewise. + (Foreach.Resolve): Likewise. + +2004-10-18 Martin Baulig + + * expression.cs (Cast.DoResolve): Don't access the TypeExpr's + `Type' directly, but call ResolveType() on it. + (Probe.DoResolve): Likewise. + (ArrayCreation.LookupType): Likewise. + (TypeOf.DoResolve): Likewise. + (SizeOf.DoResolve): Likewise. + +2004-10-18 Martin Baulig + + * expression.cs (Invocation.BetterFunction): Put back + TypeManager.TypeToCoreType(). + +2004-10-18 Raja R Harinath + + * class.cs (FieldMember.DoDefine): Reset ec.InUnsafe after doing + the ResolveType. + +2004-10-18 Martin Baulig + + * parameter.cs (Parameter.Resolve): Don't access the TypeExpr's + `Type' directly, but call ResolveType() on it. + +2004-10-18 Martin Baulig + + * class.cs (FieldMember.Define): Don't access the TypeExpr's + `Type' directly, but call ResolveType() on it. + (MemberBase.DoDefine): Likewise. + + * expression.cs (New.DoResolve): Don't access the TypeExpr's + `Type' directly, but call ResolveType() on it. + (ComposedCast.DoResolveAsTypeStep): Likewise. + + * statement.cs (LocalInfo.Resolve): Don't access the TypeExpr's + `Type' directly, but call ResolveType() on it. + +2004-10-17 John Luke + + * class.cs (Operator.GetSignatureForError): use CSharpName + + * parameter.cs (Parameter.GetSignatureForError): Returns + correct name even if was not defined. + +2004-10-13 Raja R Harinath + + Fix #65816. + * class.cs (TypeContainer.EmitContext): New property. + (DefineNestedTypes): Create an emitcontext for each part. + (MethodCore.DoDefineParameters): Use container's emitcontext. + Pass type array to InternalParameters. + (MemberBase.DoDefine): Use container's emitcontext. + (FieldMember.Define): Likewise. + (Event.Define): Likewise. + (SetMethod.GetParameterInfo): Change argument to EmitContext. + Pass type array to InternalParameters. + (SetIndexerMethod.GetParameterInfo): Likewise. + (SetMethod.Define): Pass emitcontext to GetParameterInfo. + * delegate.cs (Define): Pass emitcontext to + ComputeAndDefineParameterTypes and GetParameterInfo. Pass type + array to InternalParameters. + * expression.cs (ParameterReference.DoResolveBase): Pass + emitcontext to GetParameterInfo. + (ComposedCast.DoResolveAsTypeStep): Remove check on + ec.ResolvingTypeTree. + * parameter.cs (Parameter.Resolve): Change argument to + EmitContext. Use ResolveAsTypeTerminal. + (Parameter.GetSignature): Change argument to EmitContext. + (Parameters.ComputeSignature): Likewise. + (Parameters.ComputeParameterTypes): Likewise. + (Parameters.GetParameterInfo): Likewise. + (Parameters.ComputeAndDefineParameterTypes): Likewise. + Re-use ComputeParameterTypes. Set ec.ResolvingTypeTree. + * support.cs (InternalParameters..ctor): Remove variant that takes + a DeclSpace. + * typemanager.cs (system_intptr_expr): New. + (InitExpressionTypes): Initialize it. + +2004-10-12 Chris Toshok + + * cs-parser.jay: fix location for try_statement and catch_clause. + +2004-10-11 Martin Baulig + + * report.cs: Don't make --fatal abort on warnings, we have + -warnaserror for that. + +2004-10-07 Raja R Harinath + + More DeclSpace.ResolveType avoidance. + * decl.cs (MemberCore.InUnsafe): New property. + * class.cs (MemberBase.DoDefine): Use ResolveAsTypeTerminal + with newly created EmitContext. + (FieldMember.Define): Likewise. + * delegate.cs (Delegate.Define): Likewise. + * ecore.cs (SimpleName.ResolveAsTypeStep): Lookup with alias + only if normal name-lookup fails. + (TypeExpr.DoResolve): Enable error-checking. + * expression.cs (ArrayCreation.DoResolve): Use ResolveAsTypeTerminal. + (SizeOf.DoResolve): Likewise. + (ComposedCast.DoResolveAsTypeStep): Likewise. + (StackAlloc.DoResolve): Likewise. + * statement.cs (Block.Flags): Add new flag 'Unsafe'. + (Block.Unsafe): New property. + (Block.EmitMeta): Set ec.InUnsafe as appropriate. + (Unsafe): Set 'unsafe' flag of contained block. + (LocalInfo.Resolve): Use ResolveAsTypeTerminal. + (Fixed.Resolve): Likewise. + (Catch.Resolve): Likewise. + (Using.ResolveLocalVariableDecls): Likewise. + (Foreach.Resolve): Likewise. + +2004-10-05 John Luke + + * cs-parser.jay: add location to error CS0175 + +2004-10-04 Miguel de Icaza + + * ecore.cs (Expression.Constantity): Add support for turning null + into a constant. + + * const.cs (Const.Define): Allow constants to be reference types + as long as the value is Null. + +2004-10-04 Juraj Skripsky + + * namespace.cs (NamespaceEntry.Using): No matter which warning + level is set, check if this namespace name has already been added. + +2004-10-03 Ben Maurer + + * expression.cs: reftype [!=]= null should always use br[true,false]. + # 67410 + +2004-10-03 Marek Safar + + Fix #67108 + * attribute.cs: Enum conversion moved to + GetAttributeArgumentExpression to be applied to the all + expressions. + +2004-10-01 Raja R Harinath + + Fix #65833, test-300.cs, cs0122-5.cs, cs0122-6.cs. + * class.c (TypeContainer.DefineType): Flag error if + base types aren't accessible due to access permissions. + * decl.cs (DeclSpace.ResolveType): Move logic to + Expression.ResolveAsTypeTerminal. + (DeclSpace.ResolveTypeExpr): Thin layer over + Expression.ResolveAsTypeTerminal. + (DeclSpace.CheckAccessLevel, DeclSpace.FamilyAccess): + Refactor code into NestedAccess. Use it. + (DeclSpace.NestedAccess): New. + * ecore.cs (Expression.ResolveAsTypeTerminal): Add new + argument to silence errors. Check access permissions. + (TypeExpr.DoResolve, TypeExpr.ResolveType): Update. + * expression.cs (ProbeExpr.DoResolve): Use ResolveAsTypeTerminal. + (Cast.DoResolve): Likewise. + (New.DoResolve): Likewise. + (InvocationOrCast.DoResolve,ResolveStatement): Likewise. + (TypeOf.DoResolve): Likewise. + + * expression.cs (Invocation.BetterConversion): Return the Type of + the better conversion. Implement section 14.4.2.3 more faithfully. + (Invocation.BetterFunction): Make boolean. Make correspondence to + section 14.4.2.2 explicit. + (Invocation.OverloadResolve): Update. + (Invocation): Remove is_base field. + (Invocation.DoResolve): Don't use is_base. Use mg.IsBase. + (Invocation.Emit): Likewise. + +2004-09-27 Raja R Harinath + + * README: Update to changes. + +2004-09-24 Marek Safar + + * cs-parser.jay: Reverted 642 warning fix. + +2004-09-23 Marek Safar + + Fix bug #66615 + * decl.cs (FindMemberWithSameName): Indexer can have more than + 1 argument. + +2004-09-23 Marek Safar + + * expression.cs (LocalVariableReference.DoResolveLValue): + Do not report warning 219 for out values. + (EmptyExpression.Null): New member to avoid extra allocations. + +2004-09-23 Marek Safar + + * cs-parser.jay: Fix wrong warning 642 report. + + * cs-tokenizer.cs (CheckNextToken): New helper; + Inspect next character if is same as expected. + +2004-09-23 Martin Baulig + + * convert.cs (Convert.ImplicitReferenceConversion): Some code cleanup. + (Convert.ImplicitReferenceConversionExists): Likewise. + +2004-09-23 Marek Safar + + * class.cs (Operator.Define): Add error 448 and 559 report. + +2004-09-22 Marek Safar + + * class.cs (MemberBase.IsTypePermitted): New protected + method for checking error CS0610. + +2004-09-22 Marek Safar + + * class.cs (TypeContainer.HasExplicitLayout): New property + Returns whether container has StructLayout attribute set Explicit. + (FieldMember): New abstract class for consts and fields. + (FieldMember.ApplyAttributeBuilder): Add error 636 and 637 report. + (Field): Reuse FieldMember. + + * const.cs (Const): Reuse FieldMember. + + * rootcontext.cs: EmitConstants call moved to class. + +2004-09-22 Martin Baulig + + Thanks to Peter Sestoft for this bug report. + + * expression.cs (Conditional): If both the `trueExpr' and the + `falseExpr' is a NullLiteral, return a NullLiteral. + +2004-09-22 Martin Baulig + + * statement.cs (Foreach.EmitCollectionForeach): If we're in an + iterator, use `enumerator.EmitThis()' instead of `ec.EmitThis()' + for the "get_Current" call. + +2004-09-22 Martin Baulig + + Marek and me just fixed one of our oldest bugs: #28562 :-) + + * ecore.cs (EnumConstant.GetValueAsEnumType): New public method. + + * attribute.cs (Attribute.GetAttributeArgumentExpression): If + we're an EnumConstant, just return that. + (Attribute.Resolve): GetAttributeArgumentExpression() may give us + an EnumConstant. In this case, we need to use GetValueAsEnumType() + to get the value which'll actually be written into the attribute. + However, we have to use GetValue() to access the attribute's value + in the compiler. + +2004-09-22 Marek Safar + + * constant.cs (Constant.IsNegative): New abstract property + IsNegative. + + * expression.cs (ArrayAccess.DoResolve): Add warning 251. + (StackAlloc.DoResolve): Reused IsNegative. + +2004-09-21 Martin Baulig + + * codegen.cs (VariableStorage): Don't store the ILGenerator here; + if we're used in an iterator, we may be called from different + methods. + + * statement.cs (Foreach.EmitFinally): Only emit an `Endfinally' if + we actually have an exception block. + +2004-09-20 John Luke + + * class.cs, cs-parser.jay: Improve the error report for 1520: + report the actual line where the error happens, not where the + class was declared. + + * assign.cs, delegate.cs, ecore.cs, expression.cs, statement.cs: + Pass location information that was available elsewhere. + +2004-09-19 Sebastien Pouliot + + * codegen.cs: Fix bug #56621. It is now possible to use MCS on the MS + runtime to delay sign assemblies. + +2004-09-19 Miguel de Icaza + + * cs-parser.jay: Do not report the stack trace, this is barely + used nowadays. + +2004-08-22 John Luke + + * driver.cs : check that a resource id is not already used + before adding it, report CS1508 if it is, bug #63637 + +2004-09-19 Miguel de Icaza + + * ecore.cs: Removed dead code. + +2004-09-18 Marek Safar + + * class.cs: Do not report warning CS0067 on the interfaces. + +2004-09-16 Marek Safar + + * cs-parser.jay: Add error 504 report. + +2004-09-16 Marek Safar + + * rootcontext.cs: WarningLevel is 4 by default now. + + * statement.cs (Fixed.Resolve): Do not null + VariableInfo. + +2004-09-16 Marek Safar + + Fixed bug #55780 + * ecore.cs (PropertyExpr.FindAccessors): Do not perform + deep search when property is not virtual. + (PropertyExpr.ResolveAccessors): Make one call for both + accessors. + +2004-09-15 Marek Safar + + Fixed bug #65766 + * statement.cs: Error 152 report constains also location. + +2004-09-15 Marek Safar + + Fixed bug #65766 + * const.cs: Explicitly set constant as static. + +2004-09-15 Marek Safar + + Fixed bug #64226 + * cs-parser.jay: Add error 1017 report. + +2004-09-15 Marek Safar + + Fixed bug #59980, #64224 + * expression.cs (Invocation.DoResolve): Fixed error CS0571 test. + + * typemanager.cs (IsSpecialMethod): Simplified + +2004-09-14 Marek Safar + + * decl.cs (MemberCore.Emit): Resuscitated VerifyObsoleteAttribute + condition with better params. + +2004-09-14 Marek Safar + + Fixed bug #65238 + * attribute.cs (Resolve): Property has to have both + accessors. + +2004-09-14 Martin Baulig + + * decl.cs (MemberCore.Emit): Always call VerifyObsoleteAttribute(). + 2004-09-14 Marek Safar Fixed bug #61902