path: root/mcs/mcs/ChangeLog

2001-12-18  Miguel de Icaza  <miguel@ximian.com>

	* class.cs (Method.Define): Allow the entry point to be in a
	specific class.

	* driver.cs: Rewrite the argument handler to clean it up a bit.

	* rootcontext.cs: Made it just an auxiliary namespace feature by
	making everything static.

	* driver.cs: Adapt code to use RootContext type name instead of
	instance variable.

	* delegate.cs: Remove RootContext argument.

	* class.cs: (Struct, TypeContainer, Class): Remove RootContext
	argument. 

	* class.cs (Event.Define): The lookup can fail.
	

	* cs-tokenizer.cs: Begin implementation of pre-procesor. 

	* expression.cs: Resolve the this instance before invoking the code.

2001-12-17  Miguel de Icaza  <miguel@ximian.com>

	* cs-parser.jay: Add a production in element_access that allows
	the thing to become a "type" reference.  This way we can parse
	things like "(string [])" as a type.

	Note that this still does not handle the more complex rules of
	casts. 
	

	* delegate.cs (Delegate.Populate): Register the delegage constructor builder here. 

	* ecore.cs: (CopyNewMethods): new utility function used to
	assemble the list of methods from running FindMembers.

	(MemberLookup): Rework FindMembers so that 

2001-12-16  Miguel de Icaza  <miguel@ximian.com>

	* class.cs (TypeContainer): Remove Delegates who fail to be
	defined.

	* delegate.cs (Populate): Verify that we dont get null return
	values.   TODO: Check for AsAccessible.

	* cs-parser.jay: Use basename to emit error 574 (destructor should
	have the same name as container class), not the full name.

	* cs-tokenizer.cs (adjust_int): Fit the integer in the best
	possible representation.  

	Also implements integer type suffixes U and L.

2001-12-15  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (ArrayCreation.DoResolve): We need to do the
	argument resolution *always*.

	* decl.cs: Make this hold the namespace.  Hold the root context as
	well.
	(LookupType): Move here.

	* enum.cs, class.cs, interface.cs: Adapt to new hierarchy.

	* location.cs (Row, Name): Fixed the code, it was always returning
	references to the first file.

	* interface.cs: Register properties defined through interfaces.

	* driver.cs: Add support for globbing on the command line

	* class.cs (Field): Make it derive from MemberCore as well.
	(Event): ditto.

2001-12-15  Ravi Pratap  <ravi@ximian.com>

	* class.cs (Event::Define): Check that the type of the event is a delegate
	type else flag error #66.

	Also, re-use TypeContainer.MethodModifiersValid here too as the rules are the
	same.

	* attribute.cs (DefinePInvokeMethod): Handle named arguments and process
	values of EntryPoint, CharSet etc etc.

	Pass in the values to TypeBuilder.DefinePInvokeMethod; determine Type etc neatly.

	* class.cs (FindMembers): If a method is in transit, its MethodBuilder will
	be null and we should ignore this. I am not sure if this is really clean. Apparently,
	there's no way of avoiding hitting this because the call is coming from SimpleName.DoResolve,
	which needs this to do its work.

	* ../errors/cs0066.cs : Add.

2001-12-14  Miguel de Icaza  <miguel@ximian.com>

	* typemanager.cs: (GetPropertyGetter, GetPropertyGetter): New
	helper functions.

	* class.cs: (MethodSignature.MethodSignature): Removed hack that
	clears out the parameters field.
	(MemberSignatureCompare): Cleanup

	(MemberCore): New base class used to share code between MethodCore
	and Property.

	(RegisterRequiredImplementations) BindingFlags.Public requires
	either BindingFlags.Instace or Static.  Use instance here.

	(Property): Refactored code to cope better with the full spec.

	* parameter.cs (GetParameterInfo): Return an empty array instead
	of null on error.

	* class.cs (Property): Abstract or extern properties have no bodies.

	* parameter.cs (GetParameterInfo): return a zero-sized array.

	* class.cs (TypeContainer.MethodModifiersValid): Move all the
	method modifier validation to the typecontainer so we can reuse
	this on properties.

	(MethodCore.ParameterTypes): return an empty sized array of types.

	(Property.Define): Test property modifier validity.

	Add tests for sealed/override too.

	(Method.Emit): abstract or extern methods have no bodies.

2001-12-14  Ravi Pratap  <ravi@ximian.com>

	* class.cs (Method.IsPInvoke): Get rid of it as it is an expensive
	thing.

	(Method::Define, ::Emit): Modify accordingly.

	* expression.cs (Invocation::OverloadResolve): Handle error # 121.

	(ArrayCreation::MakeByteBlob): Handle floats and doubles.

	* makefile: Pass in /unsafe.

2001-12-13  Miguel de Icaza  <miguel@ximian.com>

	* class.cs (MakeKey): Kill routine.
	
	* class.cs (TypeContainer.Define): Correctly define explicit
	method implementations (they require the full interface name plus
	the method name).

	* typemanager.cs: Deply the PtrHashtable here and stop using the
	lame keys.  Things work so much better.

	This of course broke everyone who depended on `RegisterMethod' to
	do the `test for existance' test.  This has to be done elsewhere.

	* support.cs (PtrHashtable): A hashtable that avoid comparing with
	the object stupid Equals method (because, that like fails all over
	the place).  We still do not use it.

	* class.cs (TypeContainer.SetRequiredInterface,
	TypeContainer.RequireMethods): Killed these two routines and moved
	all the functionality to RegisterRequiredImplementations.

	(TypeContainer.RegisterRequiredImplementations): This routine now
	registers all the implementations required in an array for the
	interfaces and abstract methods.  We use an array of structures
	which can be computed ahead of time to reduce memory usage and we
	also assume that lookups are cheap as most classes will not
	implement too many interfaces.

	We also avoid creating too many MethodSignatures.

	(TypeContainer.IsInterfaceMethod): Update and optionally does not
	clear the "pending" bit if we find that there are problems with
	the declaration.

	(TypeContainer.VerifyPendingMethods): Update to report errors of
	methods that look like implementations but are not.

	(TypeContainer.Define): Add support for explicit interface method
	implementation. 
	
2001-12-12  Miguel de Icaza  <miguel@ximian.com>

	* typemanager.cs: Keep track of the parameters here instead of
	being a feature of the TypeContainer.

	* class.cs: Drop the registration of parameters here, as
	InterfaceMethods are also interface declarations.

	* delegate.cs: Register methods with the TypeManager not only with
	the TypeContainer.  This code was buggy.

	* interface.cs: Full registation here.

2001-12-11  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs: Remove reducer for binary expressions, it can not
	be done this way.

	* const.cs: Put here the code that used to go into constant.cs

	* constant.cs: Put here the code for constants, this is a new base
	class for Literals.

	* literal.cs: Make Literal derive from Constant.

2001-12-09  Miguel de Icaza  <miguel@ximian.com>

	* statement.cs (Return.Emit): Report error 157 if the user
	attempts to return from a finally block.

	(Return.Emit): Instead of emitting a return, jump to the end of
	the function.

	* codegen.cs (EmitContext): ReturnValue, ReturnLabel: new
	LocalBuilder to store the result of the function.  ReturnLabel is
	the target where we jump.
	

2001-12-09  Radek Doulik  <rodo@ximian.com>

	* cs-parser.jay: remember alias in current namespace

	* ecore.cs (SimpleName::DoResolve): use aliases for types or
	namespaces

	* class.cs (LookupAlias): lookup alias in my_namespace

	* namespace.cs (UsingAlias): add alias, namespace_or_type pair to
	aliases hashtable
	(LookupAlias): lookup alias in this and if needed in parent
	namespaces

2001-12-08  Miguel de Icaza  <miguel@ximian.com>

	* support.cs: 

	* rootcontext.cs: (ModuleBuilder) Made static, first step into
	making things static.  I need this to avoid passing the
	TypeContainer when calling ParameterType.

	* support.cs (InternalParameters.ParameterType): Remove ugly hack
	that did string manipulation to compute the type and then call
	GetType.  Use Parameter.ParameterType instead.

	* cs-tokenizer.cs: Consume the suffix for floating values.

	* expression.cs (ParameterReference): figure out whether this is a
	reference parameter or not.  Kill an extra variable by computing
	the arg_idx during emission.

	* parameter.cs (Parameters.GetParameterInfo): New overloaded
	function that returns whether a parameter is an out/ref value or not.

	(Parameter.ParameterType): The type of the parameter (base,
	without ref/out applied).
	
	(Parameter.Resolve): Perform resolution here.
	(Parameter.ExternalType): The full type (with ref/out applied).

	* statement.cs (Using.Emit, Using.EmitExpression): Implement
	support for expressions on the using statement.

2001-12-07  Miguel de Icaza  <miguel@ximian.com>

	* statement.cs (Using.EmitLocalVariableDecls): Split the
	localvariable handling of the using statement.

	(Block.EmitMeta): Keep track of variable count across blocks.  We
	were reusing slots on separate branches of blocks.

	(Try.Emit): Emit the general code block, we were not emitting it. 

	Check the type of the declaration to be an IDisposable or
	something that can be implicity converted to it. 

	Emit conversions if required.

	* ecore.cs (EmptyExpression): New utility class.
	(Expression.ImplicitConversionExists): New utility function.

2001-12-06  Miguel de Icaza  <miguel@ximian.com>

	* statement.cs (Using): Implement.

	* expression.cs (LocalVariableReference): Support read only variables.

	* statement.cs: Remove the explicit emit for the Leave opcode.
	(VariableInfo): Add a readonly field.

2001-12-05  Miguel de Icaza  <miguel@ximian.com>

	* ecore.cs (ConvCast): new class used to encapsulate the various
	explicit integer conversions that works in both checked and
	unchecked contexts.

	(Expression.ConvertNumericExplicit): Use new ConvCast class to
	properly generate the overflow opcodes.

2001-12-04  Miguel de Icaza  <miguel@ximian.com>

	* statement.cs: The correct type for the EmptyExpression is the
	element_type, not the variable type.  Ravi pointed this out.

2001-12-04  Ravi Pratap  <ravi@ximian.com>

	* class.cs (Method::Define): Handle PInvoke methods specially
	by using DefinePInvokeMethod instead of the usual one.

	* attribute.cs (DefinePInvokeMethod): Implement as this is what is called
	above to do the task of extracting information and defining the method.
	
2001-12-04  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (ArrayCreation::EmitStaticInitializers): Get rid
	of the condition for string type.

	(Emit): Move that here. 

	(ArrayCreation::CheckIndices): Keep string literals in their expression
	form.

	(EmitDynamicInitializers): Handle strings appropriately.

2001-12-04  Miguel de Icaza  <miguel@ximian.com>

	* codegen.cs (EmitContext): Replace multiple variables with a
	single pointer to the current Switch statement.

	* statement.cs (GotoDefault, Switch): Adjust to cleaned up
	EmitContext.

2001-12-03  Miguel de Icaza  <miguel@ximian.com>

	* statement.cs 

	* statement.cs (GotoDefault), cs-parser.jay: Implement `goto
	default'.
	
	(Foreach.Emit): Foreach on arrays was not setting
	up the loop variables (for break/continue).

	(GotoCase): Semi-implented.
	
2001-12-03  Ravi Pratap  <ravi@ximian.com>

	* attribute.cs (CheckAttribute): Handle system attributes by using
	Attribute.GetAttributes to examine information we need.

	(GetValidPlaces): Same here.

	* class.cs (Method::Define): Catch invalid use of extern and abstract together.

	* typemanager.cs (dllimport_type): Core type for System.DllImportAttribute.

	* class.cs (Method.IsPinvoke): Used to determine if we are a PInvoke method.

	(Method::Define): Set appropriate flags if we have a DllImport attribute.

	(Method::Emit): Handle the case when we are a PInvoke method.

2001-12-03  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs: Use ResolveWithSimpleName on compound names.

2001-12-02  Ravi Pratap  <ravi@ximian.com>

	* constant.cs (EmitConstant): Make sure we resolve the associated expression
	before trying to reduce it.

	* typemanager.cs (RegisterConstant, LookupConstant): Implement.

	* constant.cs (LookupConstantValue): Implement.

	(EmitConstant): Use the above in emitting the constant.

	* expression.cs (MemberAccess::ResolveMemberAccess): Handle constants
	that are user-defined by doing a LookupConstantValue on them.

	(SimpleName::DoResolve): When we have a FieldExpr, cope with constants
	too, like above.

2001-11-29  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (BaseAccess, BaseIndexer): Also split this out.

	(BaseAccess.DoResolve): Implement.

	(MemberAccess.DoResolve): Split this routine into a
	ResolveMemberAccess routine that can be used independently

2001-11-28  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (Probe, Is, As): Split Probe in two classes Is and
	As that share bits of the implementation.  Is returns a boolean,
	while As returns the Type that is being probed.

2001-12-01  Ravi Pratap  <ravi@ximian.com>

	* enum.cs (LookupEnumValue): Re-write various bits, return an object value
	instead of a Literal - much easier.

	(EnumInTransit): Remove - utterly useless :-)

	(Populate): Re-write bits - remove duplicate code etc. The code is much neater now.

	* expression.cs (MemberLookup): Cope with user-defined enums when they are in transit.

	* enum.cs (LookupEnumValue): Auto-compute next values by going down the dependency
	chain when we have no associated expression.

2001-11-30  Ravi Pratap  <ravi@ximian.com>

	* constant.cs (Define): Use Location while reporting the errror.

	Also emit a warning when 'new' is used and there is no inherited
	member to hide.

	* enum.cs (EnumInTransit): Used to tell if an enum type is in the process of being 
	populated.

	(LookupEnumValue): Implement to lookup an enum member's value and define it
	if necessary.

	(Populate): Re-write accordingly to use the above routine.

2001-11-27  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (This): Fix prototype for DoResolveLValue to
	override the base class DoResolveLValue.

	* cs-parser.cs: Report errors cs574 and cs575 (destructor
	declarations) 

	* ecore.cs (FieldExpr.EmitAssign): Handle value types specially
	(we need to load the address of the field here).  This fixes
	test-22. 
	
	(FieldExpr.DoResolveLValue): Call the DoResolve
	function to initialize the Instance expression.
	
	* statement.cs (Foreach.Emit): Fix the bug where we did not invoke
	correctly the GetEnumerator operation on a value type.

	* cs-parser.jay: Add more simple parsing error catches.

	* statement.cs (Switch): Add support for string switches.
	Handle null specially.

	* literal.cs (NullLiteral): Make NullLiteral objects singletons. 

2001-11-28  Ravi Pratap  <ravi@ximian.com>

	* cs-parser.jay (local_constant_declaration): Use declare_local_constant.

	(declare_local_constant): New helper function.

	* statement.cs (AddConstant): Keep a separate record of constants

	(IsConstant): Implement to determine if a variable is a constant.

	(GetConstantExpression): Implement.

	* expression.cs (LocalVariableReference): Handle the case when it is a constant.

	* statement.cs (IsVariableDefined): Re-write.

2001-11-27  Ravi Pratap  <ravi@ximian.com>

	* class.cs (TypeContainer::FindMembers): Look for constants
	in the case when we are looking for MemberTypes.Field

	* expression.cs (MemberAccess::DoResolve): Check that in the
	case we are a FieldExpr and a Literal, we are not being accessed
	by an instance reference.

	* cs-parser.jay (local_constant_declaration): Implement.

	(declaration_statement): Implement for constant declarations.

2001-11-26  Miguel de Icaza  <miguel@ximian.com>

	* statement.cs (Switch): Catch double defaults.

	(Switch): More work on the switch() statement
	implementation.  It works for integral values now, need to finish
	string support.


2001-11-24  Miguel de Icaza  <miguel@ximian.com>

	* ecore.cs (Expression.ConvertIntLiteral): New function to convert
	integer literals into other integer literals.  To be used by
	switch. 

2001-11-24  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (ArrayCreation): Get rid of ArrayExprs : we save
	some memory.

	(EmitDynamicInitializers): Cope with the above since we extract data
	directly from ArrayData now.

	(ExpectInitializers): Keep track of whether initializers are mandatory
	or not.

	(Bounds): Make it a hashtable to prevent the same dimension being 
	recorded for every element in that dimension.

	(EmitDynamicInitializers): Fix bug which prevented the Set array method
	from being found.

	Also fix bug which was causing the indices to be emitted in the reverse
	order.

2001-11-24  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (ArrayCreation): Implement the bits that Ravi left
	unfinished.  They do not work, because the underlying code is
	sloppy.

2001-11-22  Miguel de Icaza  <miguel@ximian.com>

	* cs-parser.jay: Remove bogus fixme.

	* statement.cs (Switch, SwitchSection, SwithLabel): Started work
	on Switch statement.
	
2001-11-23  Ravi Pratap  <ravi@ximian.com>

	* typemanager.cs (IsDelegateType, IsEnumType): Fix logic to determine
	the same. 
	
	* expression.cs (ArrayCreation::CheckIndices): Get rid of the require_constant
	parameter. Apparently, any expression is allowed. 

	(ValidateInitializers): Update accordingly.

	(CheckIndices): Fix some tricky bugs thanks to recursion.

	* delegate.cs (NewDelegate::DoResolve): Re-write large portions as 
	I was being completely brain-dead.

	(VerifyMethod, VerifyApplicability, VerifyDelegate): Make static
	and re-write acordingly.

	(DelegateInvocation): Re-write accordingly.

	* expression.cs (ArrayCreation::Emit): Handle string initialization separately.

	(MakeByteBlob): Handle types more correctly.

	* expression.cs (ArrayCreation:Emit): Write preliminary code to do
	initialization from expressions but it is incomplete because I am a complete
	Dodo :-|

2001-11-22  Miguel de Icaza  <miguel@ximian.com>

	* statement.cs (If.Emit): Fix a bug that generated incorrect code
	on If.  Basically, we have to return `true' (ie, we do return to
	our caller) only if both branches of the if return.

	* expression.cs (Binary.Emit): LogicalOr and LogicalAnd are
	short-circuit operators, handle them as short circuit operators. 

	(Cast.DoResolve): Resolve type.
	(Cast.Cast): Take an expression as the target type.

	* cs-parser.jay (cast_expression): Remove old hack that only
	allowed a limited set of types to be handled.  Now we take a
	unary_expression and we resolve to a type during semantic
	analysis.

	Use the grammar productions from Rhys to handle casts (this is
	not complete like Rhys syntax yet, we fail to handle that corner
	case that C# has regarding (-x), but we will get there.
	
2001-11-22  Ravi Pratap  <ravi@ximian.com>

	* class.cs (EmitFieldInitializer): Take care of the case when we have a
	field which is an array type.

	* cs-parser.jay (declare_local_variables): Support array initialization too.

	* typemanager.cs (MakeKey): Implement.

	(everywhere): Use the above appropriately.

	* cs-parser.jay (for_statement): Update for array initialization while
	declaring variables.

	* ecore.cs : The error message was correct, it's the variable's names that
	were misleading ;-) Make the code more readable.

	(MemberAccess::DoResolve): Fix the code which handles Enum literals to set
	the correct type etc.

	(ConvertExplicit): Handle Enum types by examining the underlying type.

2001-11-21  Ravi Pratap  <ravi@ximian.com>

	* parameter.cs (GetCallingConvention): Always return
	CallingConventions.Standard for now.

2001-11-22  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (Binary.ResolveOperator): Update the values of `l'
	and `r' after calling DoNumericPromotions.

	* ecore.cs: Fix error message (the types were in the wrong order).

	* statement.cs (Foreach.ProbeCollectionType): Need to pass
	BindingFlags.Instance as well 

	* ecore.cs (Expression.TryImplicitIntConversion): Wrap the result
	implicit int literal conversion in an empty cast so that we
	propagate the right type upstream.

	(UnboxCast): new class used to unbox value types.
	(Expression.ConvertExplicit): Add explicit type conversions done
	by unboxing.

	(Expression.ImplicitNumericConversion): Oops, forgot to test for
	the target type before applying the implicit LongLiterals to ULong
	literal cast.

2001-11-21  Miguel de Icaza  <miguel@ximian.com>

	* cs-parser.jay (for_statement): Reworked the way For works: now
	we declare manually any variables that are introduced in
	for_initializer to solve the problem of having out-of-band code
	emition (that is what got for broken).

	(declaration_statement): Perform the actual variable declaration
	that used to be done in local_variable_declaration here.

	(local_variable_declaration): Do not declare anything, just pass
	the information on a DictionaryEntry

2001-11-20  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (ArrayCreation::CheckIndices): The story continues :-) Complete
	re-write of the logic to now make it recursive.

	(UpdateIndices): Re-write accordingly.

	Store element data in a separate ArrayData list in the above methods.

	(MakeByteBlob): Implement to dump the array data into a byte array.

2001-11-19  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (ArrayCreation): Factor out some code from ValidateInitializers
	into CheckIndices.

	* constant.cs (Define): Implement.

	(EmitConstant): Re-write fully.

	Pass in location info.

	* class.cs (Populate, Emit): Call Constant::Define and Constant::EmitConstant
	respectively.

	* cs-parser.jay (constant_declarator): Use VariableDeclaration instead of
	DictionaryEntry since we need location info too.

	(constant_declaration): Update accordingly.

	* expression.cs (ArrayCreation): Make ValidateInitializers simpler by factoring
	code into another method : UpdateIndices.

2001-11-18  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (ArrayCreation::ValidateInitializers): Update to perform
	some type checking etc.

2001-11-17  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (ArrayCreation::ValidateInitializers): Implement
	bits to provide dimension info if the user skips doing that.

	Update second constructor to store the rank correctly.

2001-11-16  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (ArrayCreation::ValidateInitializers): Poke around
	and try to implement.

	* ../errors/cs0150.cs : Add.

	* ../errors/cs0178.cs : Add.

2001-11-16  Miguel de Icaza  <miguel@ximian.com>

	* statement.cs: Implement foreach on multi-dimensional arrays. 

	* parameter.cs (Parameters.GetParameterByName): Also lookup the
	name of the params argument.

	* expression.cs: Use EmitStoreOpcode to get the right opcode while
	initializing the array.

	(ArrayAccess.EmitStoreOpcode): move the opcode generation here, so
	we can use this elsewhere.

	* statement.cs: Finish implementation of foreach for single
	dimension arrays.

	* cs-parser.jay: Use an out-of-band stack to pass information
	around, I wonder why I need this.

	foreach_block: Make the new foreach_block the current_block.

	* parameter.cs (Parameters.GetEmptyReadOnlyParameters): New
	function used to return a static Parameters structure.  Used for
	empty parameters, as those are created very frequently.

	* cs-parser.jay, class.cs: Use GetEmptyReadOnlyParameters

2001-11-15  Ravi Pratap  <ravi@ximian.com>

	* interface.cs : Default modifier is private, not public. The
	make verify test passes again.

2001-11-15  Ravi Pratap  <ravi@ximian.com>

	* support.cs (ReflectionParameters): Fix logic to determine
	whether the last parameter is a params one. Test 9 passes again.

	* delegate.cs (Populate): Register the builders we define with
	RegisterParameterForBuilder. Test 19 passes again.

	* cs-parser.jay (property_declaration): Reference $6 instead
	of $$ to get at the location.

	(indexer_declaration): Similar stuff.

	(attribute): Ditto.

	* class.cs (Property): Register parameters for the Get and Set methods
	if they exist. Test 23 passes again.

	* expression.cs (ArrayCreation::Emit): Pass null for the method in the
	call to EmitArguments as we are sure there aren't any params arguments. 
	Test 32 passes again.

	* suppor.cs (ParameterDesc, ParameterModifier): Fix trivial bug causing
	IndexOutOfRangeException. 

	* class.cs (Property::Define): Register property using TypeManager.RegisterProperty
	Test 33 now passes again.
	
2001-11-15  Miguel de Icaza  <miguel@ximian.com>

	* cs-parser.jay: Kill horrendous hack ($??? = lexer.Location) that
	broke a bunch of things.  Will have to come up with a better way
	of tracking locations.

	* statement.cs: Implemented foreach for single dimension arrays.

2001-11-09  Miguel de Icaza  <miguel@ximian.com>

	* enum.cs (Enum.Emit): Delay the lookup of loc until we run into
	an error.  This removes the lookup from the critical path.

	* cs-parser.jay: Removed use of temporary_loc, which is completely
	broken. 

2001-11-14  Miguel de Icaza  <miguel@ximian.com>

	* support.cs (ReflectionParameters.ParameterModifier): Report
	whether the argument is a PARAMS argument or not.

	* class.cs: Set the attribute `ParamArrayAttribute' on the
	parameter argument.

	* typemanager.cs: Define param_array_type (ParamArrayAttribute)
	and cons_param_array_attribute (ConstructorInfo for
	ParamArrayAttribute)., 

	* codegen.cs: Emit the return using the `Return' statement, that
	way we can report the error correctly for missing return values. 

	* class.cs (Method.Emit): Clean up.

	* expression.cs (Argument.Resolve): Take another argument: the
	location where this argument is used.  Notice that this is not
	part of the "Argument" class as to reduce the size of the
	structure (we know the approximate location anyways).

	Test if the argument is a variable-reference, if not, then
	complain with a 206.

	(Argument.Emit): Emit addresses of variables.

	(Argument.FullDesc): Simplify.

	(Invocation.DoResolve): Update for Argument.Resolve.

	(ElementAccess.DoResolve): ditto.

	* delegate.cs (DelegateInvocation.Emit): Invocation of Invoke
	method should be virtual, as this method is always virtual.

	(NewDelegate.DoResolve): Update for Argument.Resolve.

	* class.cs (ConstructorInitializer.DoResolve): ditto.
	
	* attribute.cs (Attribute.Resolve): ditto.

2001-11-13  Miguel de Icaza  <miguel@ximian.com>

	* statement.cs (Foreach.Emit): Use EmitAssign instead of Store.

	* expression.cs (ParameterReference): Drop IStackStorage and implement
	IAssignMethod instead. 

	(LocalVariableReference): ditto.
	
	* ecore.cs (FieldExpr): Drop IStackStorage and implement
	IAssignMethod instead. 

2001-11-13  Miguel de Icaza <miguel@ximian.com>

	* parameter.cs, expression.cs, class.cs, ecore.cs: Made all
	enumerations that are used in heavily used structures derive from
	byte in a laughable and pathetic attempt to reduce memory usage.
	This is the kind of pre-optimzations that you should not do at
	home without adult supervision.

	* expression.cs (UnaryMutator): New class, used to handle ++ and
	-- separatedly from the other unary operators.  Cleans up the
	code, and kills the ExpressionStatement dependency in Unary.

	(Unary): Removed `method' and `Arguments' from this class, making
	it smaller, and moving it all to SimpleCall, so I can reuse this
	code in other locations and avoid creating a lot of transient data
	strucutres when not required.

	* cs-parser.jay: Adjust for new changes.

2001-11-11  Miguel de Icaza  <miguel@ximian.com>

	* enum.cs (Enum.Populate): If there is a failure during
	definition, return

	* cs-parser.jay (opt_enum_base): we used to catch type errors
	here, but this is really incorrect.  The type error should be
	catched during semantic analysis.

2001-12-11  Ravi Pratap  <ravi@ximian.com>

	* cs-parser.jay (operator_declarator, conversion_operator_declarator): Set
	current_local_parameters as expected since I, in my stupidity, had forgotten
	to do this :-)

	* attribute.cs (GetValidPlaces): Fix stupid bug.

	* class.cs (Method::Emit): Perform check on applicability of attributes.

	(Constructor::Emit): Ditto.

	(Field::Emit): Ditto.

	(Field.Location): Store location information.

	(Property, Event, Indexer, Operator): Ditto.

	* cs-parser.jay (field_declaration): Pass in location for each field.

	* ../errors/cs0592.cs : Add.

2001-11-12  Ravi Pratap  <ravi@ximian.com>

	* typemanager.cs (attribute_usage_type): New static member for System.AttributeUsage.

	(InitCoreTypes): Update accordingly.

	(RegisterAttrType, LookupAttr): Implement.

	* attribute.cs (Attribute.Targets, AllowMultiple, Inherited): New fields to hold
	info about the same.

	(Resolve): Update to populate the above as necessary.

	(Error592): Helper.

	(GetValidPlaces): Helper to the above.

	(CheckAttribute): Implement to perform validity of attributes on declarative elements.

	* class.cs (TypeContainer::Emit): Update attribute emission code to perform checking etc.

2001-11-12  Ravi Pratap  <ravi@ximian.com>

	* attribute.cs (Attribute::Resolve): Expand to handle named arguments too.

	* ../errors/cs0617.cs : Add.

2001-11-11  Ravi Pratap  <ravi@ximian.com>

	* enum.cs (Emit): Rename to Populate to be more consistent with what
	we expect it to do and when exactly it is called.

	* class.cs, rootcontext.cs : Update accordingly.

	* typemanager.cs (RegisterField, GetValue): Workarounds for the fact that
	FieldInfo.GetValue does not work on dynamic types ! S.R.E lameness strikes again !

	* enum.cs (Populate): Register fields with TypeManager.RegisterField.

	* expression.cs (MemberAccess.DoResolve): Adjust code to obtain the value
	of a fieldinfo using the above, when dealing with a FieldBuilder.

2001-11-10  Ravi Pratap  <ravi@ximian.com>

	* ../errors/cs0031.cs : Add.

	* ../errors/cs1008.cs : Add.

	* ../errrors/cs0543.cs : Add.

	* enum.cs (DefineEnum): Check the underlying type and report an error if not a valid
	enum type.

	(FindMembers): Implement.

	* typemanager.cs (FindMembers): Re-write to call the appropriate methods for
	enums and delegates too.

	(enum_types): Rename to builder_to_enum.

	(delegate_types): Rename to builder_to_delegate.

	* delegate.cs (FindMembers): Implement.

2001-11-09  Ravi Pratap  <ravi@ximian.com>

	* typemanager.cs (IsEnumType): Implement.

	* enum.cs (Emit): Re-write parts to account for the underlying type
	better and perform checking etc.

	(GetNextDefaultValue): Helper to ensure we don't overshoot max value
	of the underlying type.

	* literal.cs (GetValue methods everywhere): Perform bounds checking and return
	value

	* enum.cs (error31): Helper to report error #31.

	* cs-parser.jay (enum_declaration): Store location of each member too.

	* enum.cs (member_to_location): New hashtable. 

	(AddEnumMember): Update location hashtable.

	(Emit): Use the location of each member while reporting errors.

2001-11-09  Miguel de Icaza  <miguel@ximian.com>

	* cs-parser.jay: A for_initializer if is a
	local_variable_declaration really ammount to have an implicit
	block with the variable declaration and no initializer for for.

	* statement.cs (For.Emit): Cope with null initializers.

	This fixes the infinite loop on for initializers.

2001-11-08  Miguel de Icaza  <miguel@ximian.com>

	* enum.cs: More cleanup.

	* ecore.cs: Remove dead code.

	* class.cs (Property.Emit): More simplification.
	(Event.Emit): ditto.

	Reworked to have less levels of indentation.
	
2001-11-08  Ravi Pratap  <ravi@ximian.com>

	* class.cs (Property): Emit attributes.

	(Field): Ditto.
	
	(Event): Ditto.

	(Indexer): Ditto.

	(Operator): Ditto.

	* enum.cs (Emit): Ditto.

	* rootcontext.cs (ResolveTree, EmitCode, CloseTypes): Do the same for
	Enums too.

	* class.cs (Field, Event, etc.): Move attribute generation into the
	Emit method everywhere.

	* enum.cs (Enum): Revamp to use the same definition semantics as delegates so
	we have a DefineEnum, CloseEnum etc. The previous way of doing things was not right
	as we had no way of defining nested enums !

	* rootcontext.cs : Adjust code accordingly.

	* typemanager.cs (AddEnumType): To keep track of enum types separately.

2001-11-07  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (EvalConstantExpression): Move into ecore.cs
	
	* enum.cs (Enum): Rename some members and make them public and readonly
	according to our convention.

	* modifiers.cs (EnumAttr): Implement as we need to set only visibility flags,
	nothing else.

	* enum.cs (Enum::Define): Use the above instead of TypeAttr.

	(Enum::Emit): Write a simple version for now which doesn't try to compute
	expressions. I shall modify this to be more robust in just a while.

	* class.cs (TypeContainer::Emit): Make sure we include Enums too.

	(TypeContainer::CloseType): Create the Enum types too.

	* attribute.cs (Resolve): Use the new Reduce method instead of EvalConstantExpression.

	* expression.cs (EvalConstantExpression): Get rid of completely.

	* enum.cs (Enum::Emit): Use the new expression reducer. Implement assigning
	user-defined values and other cases.

	(IsValidEnumLiteral): Helper function.

	* expression.cs (ExprClassfromMemberInfo): Modify to not do any literalizing 
	out there in the case we had a literal FieldExpr.

	(MemberAccess:DoResolve): Do the literalizing of the FieldExpr here.

	(Literalize): Revamp a bit to take two arguments.
	
	(EnumLiteral): New class which derives from Literal to wrap enum literals.
	
2001-11-06  Ravi Pratap  <ravi@ximian.com>

	* cs-parser.jay (compilation_unit): Remove extra opt_attributes for now.

	* expression.cs (ArrayCreation::ValidateInitializers): Implement.

	(Resolve): Use the above to ensure we have proper initializers.

2001-11-05  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (Expression::EvalConstantExpression): New method to 
	evaluate constant expressions.

	* attribute.cs (Attribute::Resolve): Modify bits to use the above function.

2001-11-07  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (ArrayCreation.Emit): Some bits to initialize data
	in an array.

	(Binary.ResolveOperator): Handle operator != (object a, object b)
	and operator == (object a, object b);

	(Binary.DoNumericPromotions): Indicate whether the numeric
	promotion was possible.

	(ArrayAccess.DoResolve, ArrayAccess.Emit, ArrayAccess.EmitAssign):
	Implement.  

	Made the ArrayAccess implement interface IAssignMethod instead of
	IStackStore as the order in which arguments are passed reflects
	this.

	* assign.cs: Instead of using expr.ExprClass to select the way of
	assinging, probe for the IStackStore/IAssignMethod interfaces.

	* typemanager.cs: Load InitializeArray definition.

	* rootcontext.cs (RootContext.MakeStaticData): Used to define
	static data that can be used to initialize arrays. 

2001-11-05  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs: Handle operator== and operator!= for booleans.

	(Conditioal.Reduce): Implement reducer for the ?: operator.

	(Conditional.Resolve): Implement dead code elimination.

	(Binary.Resolve): Catch string literals and return a new
	concatenated string.

	(Unary.Reduce): Implement reduction of unary expressions.

	* ecore.cs: Split out the expression core handling here.

	(Expression.Reduce): New method used to perform constant folding
	and CSE.  This is needed to support constant-expressions. 
	
	* statement.cs (Statement.EmitBoolExpression): Pass true and false
	targets, and optimize for !x.

2001-11-04  Ravi Pratap  <ravi@ximian.com>

	* attribute.cs (Attribute::Resolve): Implement guts. Note that resolution
	of an attribute gives us a CustomAttributeBuilder which we use accordingly to
	set custom atttributes.

	* literal.cs (Literal::GetValue): New abstract method to return the actual
	value of the literal, cast as an object.

	(*Literal): Implement GetValue method.

	* cs-parser.jay (positional_argument_list, named_argument_list): Add not just plain
	expressions to the arraylist but objects of type Argument.

	* class.cs (TypeContainer::Emit): Emit our attributes too.

	(Method::Emit, Constructor::Emit): Ditto.

	* cs-parser.jay (constructor_declaration): Set attributes too, which we seemed
	to be ignoring earlier.

2001-11-03  Ravi Pratap  <ravi@ximian.com>

	* attribute.cs (AttributeSection::Define): Implement to do the business
	of constructing a CustomAttributeBuilder.

	(Attribute): New trivial class. Increases readability of code.	

	* cs-parser.jay : Update accordingly.

	(positional_argument_list, named_argument_list, named_argument): New rules

	(attribute_arguments): Use the above so that we are more correct.
	
2001-11-02  Ravi Pratap  <ravi@ximian.com>
	
	* expression.cs (Invocation::IsParamsMethodApplicable): Implement
	to perform all checks for a method with a params parameter.

	(Invocation::OverloadResolve): Update to use the above method and therefore
	cope correctly with params method invocations.

	* support.cs (InternalParameters::ParameterDesc): Provide a desc for 
	params too.

	* class.cs (ConstructorInitializer::Resolve): Make sure we look for Non-public
	constructors in our parent too because we can't afford to miss out on 
	protected ones ;-)

	* attribute.cs (AttributeSection): New name for the class Attribute

	Other trivial changes to improve readability.

	* cs-parser.jay (opt_attributes, attribute_section etc.): Modify to
	use the new class names.
	
2001-11-01  Ravi Pratap  <ravi@ximian.com>

	* class.cs (Method::Define): Complete definition for params types too

	(Indexer::Define): Ditto.

	* support.cs (InternalParameters::ParameterType, ParameterDesc, ParameterModifier):
	Cope everywhere with a request for info about the array parameter.

2001-11-01  Ravi Pratap  <ravi@ximian.com>

	* tree.cs (RecordNamespace): Fix up to check for the correct key.

	* cs-parser.jay (GetQualifiedIdentifier): New Helper method used in 
	local_variable_type to extract the string corresponding to the type.

	(local_variable_type): Fixup the action to use the new helper method.

	* codegen.cs : Get rid of RefOrOutParameter, it's not the right way to 
	go.

	* expression.cs : Clean out code which uses the above.

2001-10-31  Ravi Pratap  <ravi@ximian.com>
	
	* typemanager.cs (RegisterMethod): Check if we already have an existing key
	and bale out if necessary by returning a false.

	(RegisterProperty): Ditto.

	* class.cs (everywhere): Check the return value from TypeManager.RegisterMethod
	and print out appropriate error messages.

	* interface.cs (everywhere): Ditto.

	* cs-parser.jay (property_declaration, event_declaration, indexer_declaration): Pass
	location to constructor.

	* class.cs (Property, Event, Indexer): Update accordingly.

	* ../errors/cs111.cs : Added.

	* expression.cs (Invocation::IsApplicable): New static method to determine applicability
	of a method, as laid down by the spec.

	(Invocation::OverloadResolve): Use the above method.

2001-10-31  Ravi Pratap  <ravi@ximian.com>

	* support.cs (InternalParameters): Get rid of crap taking in duplicate info. We
	now take a TypeContainer and a Parameters object.

	(ParameterData): Modify return type of ParameterModifier method to be 
	Parameter.Modifier and not a string.

	(ReflectionParameters, InternalParameters): Update accordingly.

	* expression.cs (Argument::GetParameterModifier): Same here.

	* support.cs (InternalParameters::ParameterType): Find a better way of determining
	if we are a ref/out parameter. Actually, the type shouldn't be holding the '&'
	symbol in it at all so maybe this is only for now.

2001-10-30  Ravi Pratap  <ravi@ximian.com>

	* support.cs (InternalParameters): Constructor now takes an extra argument 
	which is the actual Parameters class.

	(ParameterDesc): Update to provide info on ref/out modifiers.

	* class.cs (everywhere): Update call to InternalParameters to pass in
	the second argument too.

	* support.cs (ParameterData): Add ParameterModifier, which is a method 
	to return the modifier info [ref/out etc]

	(InternalParameters, ReflectionParameters): Implement the above.

	* expression.cs (Argument::ParameterModifier): Similar function to return
	info about the argument's modifiers.

	(Invocation::OverloadResolve): Update to take into account matching modifiers 
	too.

	* class.cs (Indexer::Define): Actually define a Parameter object and put it onto
	a new SetFormalParameters object which we pass to InternalParameters.

2001-10-30  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (NewArray): Merge into the ArrayCreation class.

2001-10-29  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (NewArray): Merge classes NewBuiltinArray and 
	NewUserdefinedArray into one as there wasn't much of a use in having
	two separate ones.

	* expression.cs (Argument): Change field's name to ArgType from Type.

	(Type): New readonly property which returns the proper type, taking into 
	account ref/out modifiers.

	(everywhere): Adjust code accordingly for the above.

	* codegen.cs (EmitContext.RefOrOutParameter): New field to determine
	whether we are emitting for a ref or out parameter.

	* expression.cs (Argument::Emit): Use the above field to set the state.

	(LocalVariableReference::Emit): Update to honour the flag and emit the
	right stuff.

	* parameter.cs (Attributes): Set the correct flags for ref parameters.

	* expression.cs (Argument::FullDesc): New function to provide a full desc.

	* support.cs (ParameterData): Add method ParameterDesc to the interface.

	(ReflectionParameters, InternalParameters): Implement the above method.

	* expression.cs (Invocation::OverloadResolve): Use the new desc methods in
	reporting errors.

	(Invocation::FullMethodDesc): Ditto. 

2001-10-29  Miguel de Icaza  <miguel@ximian.com>

	* cs-parser.jay: Add extra production for the second form of array
	creation. 

	* expression.cs (ArrayCreation): Update to reflect the above
	change. 

	* Small changes to prepare for Array initialization.

2001-10-28  Miguel de Icaza  <miguel@ximian.com>

	* typemanager.cs (ImplementsInterface): interface might be null;
	Deal with this problem;

	Also, we do store negative hits on the cache (null values), so use
	this instead of calling t.GetInterfaces on the type everytime.

2001-10-28  Ravi Pratap  <ravi@ximian.com>

	* typemanager.cs (IsBuiltinType): New method to help determine the same.

	* expression.cs (New::DoResolve): Get rid of array creation code and instead
	split functionality out into different classes.

	(New::FormArrayType): Move into NewBuiltinArray.

	(Invocation::EmitArguments): Get rid of the MethodBase argument. Appears
	quite useless.

	(NewBuiltinArray): New class to handle creation of built-in arrays.

	(NewBuiltinArray::DoResolve): Implement guts of array creation. Also take into
	account creation of one-dimensional arrays.

	(::Emit): Implement to use Newarr and Newobj opcodes accordingly.

	(NewUserdefinedArray::DoResolve): Implement.

	* cs-parser.jay (local_variable_type): Fix up to add the rank to the variable too.

	* typemanager.cs (AddModule): Used to add a ModuleBuilder to the list of modules
	we maintain inside the TypeManager. This is necessary to perform lookups on the
	module builder.

	(LookupType): Update to perform GetType on the module builders too.	

	* driver.cs (Driver): Add the ModuleBuilder to the list maintained by the TypeManager.

	* exprssion.cs (NewUserdefinedArray::Emit): Implement.

2001-10-23  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (New::DoResolve): Implement guts of array creation.

	(New::FormLookupType): Rename to FormArrayType and modify ever so slightly.
	
2001-10-27  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs: Fix bug I introduced lsat night that broke
	Delegates. 

	(Expression.Resolve): Report a 246 error (can not resolve name)
	if we find a SimpleName in the stream.
	
	(Expression.ResolveLValue): Ditto.
	
	(Expression.ResolveWithSimpleName): This function is a variant of
	ResolveName, this one allows SimpleNames to be returned without a
	warning.  The only consumer of SimpleNames is MemberAccess

2001-10-26  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (Invocation::DoResolve): Catch SimpleNames that
	might arrive here.  I have my doubts that this is correct.

	* statement.cs (Lock): Implement lock statement.

	* cs-parser.jay: Small fixes to support `lock' and `using'

	* cs-tokenizer.cs: Remove extra space

	* driver.cs: New flag --checked, allows to turn on integer math
	checking. 

	* typemanger.cs: Load methodinfos for Threading.Monitor.Enter and
	Threading.Monitor.Exit 
	
2001-10-23  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (IndexerAccess::DoResolveLValue): Set the
	Expression Class to be IndexerAccess.

	Notice that Indexer::DoResolve sets the eclass to Value.

2001-10-22  Miguel de Icaza  <miguel@ximian.com>

	* class.cs (TypeContainer::Emit): Emit code for indexers.

	* assign.cs (IAssignMethod): New interface implemented by Indexers
	and Properties for handling assignment.

	(Assign::Emit): Simplify and reuse code. 
	
	* expression.cs (IndexerAccess, PropertyExpr): Implement
	IAssignMethod, clean up old code. 

2001-10-22  Ravi Pratap  <ravi@ximian.com>

	* typemanager.cs (ImplementsInterface): New method to determine if a type
	implements a given interface. Provides a nice cache too.

	* expression.cs (ImplicitReferenceConversion): Update checks to use the above
	method.

	(ConvertReferenceExplicit): Ditto.

	* delegate.cs (Delegate::Populate): Update to define the parameters on the 
	various methods, with correct names etc.

	* class.cs (Operator::OpType): New members Operator.UnaryPlus and 
	Operator.UnaryNegation.

	* cs-parser.jay (operator_declarator): Be a little clever in the case where
	we have a unary plus or minus operator.

	* expression.cs (Unary): Rename memebers of Operator enum to UnaryPlus and 
	UnaryMinus.

	* everywhere : update accordingly.

	* everywhere : Change Negate and BitComplement to LogicalNot and OnesComplement
	respectively.

	* class.cs (Method::Define): For the case where we are implementing a method
	inherited from an interface, we need to set the MethodAttributes.Final flag too. 
	Also set MethodAttributes.NewSlot and MethodAttributes.HideBySig.
	
2001-10-21  Ravi Pratap  <ravi@ximian.com>

	* interface.cs (FindMembers): Implement to work around S.R.E
	lameness.

	* typemanager.cs (IsInterfaceType): Implement.

	(FindMembers): Update to handle interface types too.

	* expression.cs (ImplicitReferenceConversion): Re-write bits which
	use IsAssignableFrom as that is not correct - it doesn't work.

	* delegate.cs (DelegateInvocation): Derive from ExpressionStatement
	and accordingly override EmitStatement.

	* expression.cs (ConvertReferenceExplicit): Re-write similary, this time
	using the correct logic :-)

2001-10-19  Ravi Pratap  <ravi@ximian.com>

	* ../errors/cs-11.cs : Add to demonstrate error -11 

2001-10-17  Miguel de Icaza  <miguel@ximian.com>

	* assign.cs (Assign::Resolve): Resolve right hand side first, and
	then pass this as a hint to ResolveLValue.
	
	* expression.cs (FieldExpr): Add Location information

	(FieldExpr::LValueResolve): Report assignment to readonly
	variable. 
	
	(Expression::ExprClassFromMemberInfo): Pass location information.

	(Expression::ResolveLValue): Add new method that resolves an
	LValue. 

	(Expression::DoResolveLValue): Default invocation calls
	DoResolve. 

	(Indexers): New class used to keep track of indexers in a given
	Type. 

	(IStackStore): Renamed from LValue, as it did not really describe
	what this did.  Also ResolveLValue is gone from this interface and
	now is part of Expression.

	(ElementAccess): Depending on the element access type
	
	* typemanager.cs: Add `indexer_name_type' as a Core type
	(System.Runtime.CompilerServices.IndexerNameAttribute)

	* statement.cs (Goto): Take a location.
	
2001-10-18  Ravi Pratap  <ravi@ximian.com>

	* delegate.cs (Delegate::VerifyDelegate): New method to verify
	if two delegates are compatible.

	(NewDelegate::DoResolve): Update to take care of the case when
	we instantiate a delegate from another delegate.

	* typemanager.cs (FindMembers): Don't even try to look up members
	of Delegate types for now.

2001-10-18  Ravi Pratap  <ravi@ximian.com>

	* delegate.cs (NewDelegate): New class to take care of delegate
	instantiation.

	* expression.cs (New): Split the delegate related code out into 
	the NewDelegate class.

	* delegate.cs (DelegateInvocation): New class to handle delegate 
	invocation.

	* expression.cs (Invocation): Split out delegate related code into
	the DelegateInvocation class.

2001-10-17  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (New::DoResolve): Implement delegate creation fully
	and according to the spec.

	(New::DoEmit): Update to handle delegates differently.

	(Invocation::FullMethodDesc): Fix major stupid bug thanks to me
	because of which we were printing out arguments in reverse order !

	* delegate.cs (VerifyMethod): Implement to check if the given method
	matches the delegate.

	(FullDelegateDesc): Implement.

	(VerifyApplicability): Implement.

	* expression.cs (Invocation::DoResolve): Update to accordingly handle
	delegate invocations too.

	(Invocation::Emit): Ditto.

	* ../errors/cs1593.cs : Added.

	* ../errors/cs1594.cs : Added.

	* delegate.cs (InstanceExpression, TargetMethod): New properties.

2001-10-16  Ravi Pratap  <ravi@ximian.com>

	* typemanager.cs (intptr_type): Core type for System.IntPtr

	(InitCoreTypes): Update for the same.

	(iasyncresult_type, asynccallback_type): Ditto.

	* delegate.cs (Populate): Fix to use System.Intptr as it is indeed
	correct.

	* typemanager.cs (AddDelegateType): Store a pointer to the Delegate class
	too.

	* delegate.cs (ConstructorBuilder, InvokeBuilder, ...): New members to hold
	the builders for the 4 members of a delegate type :-)

	(Populate): Define the BeginInvoke and EndInvoke methods on the delegate
	type.

	* expression.cs (New::DoResolve): Implement guts for delegate creation.

	* ../errors/errors.txt : Update for an error (-11) which only we catch :-)

2001-10-15  Miguel de Icaza  <miguel@ximian.com>

	* statement.cs (Break::Emit): Implement.   
	(Continue::Emit): Implement.

	(For::Emit): Track old being/end loops;  Set Begin loop, ack end loop
	(While::Emit): Track old being/end loops;  Set Begin loop, ack end loop
	(Do::Emit): Track old being/end loops;  Set Begin loop, ack end loop
	(Foreach::Emit): Track old being/end loops;  Set Begin loop, ack
	end loop
	
	* codegen.cs (EmitContext::LoopEnd, EmitContext::LoopBegin): New
	properties that track the label for the current loop (begin of the
	loop and end of the loop).

2001-10-15  Ravi Pratap  <ravi@ximian.com>

	* delegate.cs (Emit): Get rid of it as there doesn't seem to be any ostensible
	use of emitting anything at all.

	* class.cs, rootcontext.cs : Get rid of calls to the same.

	* delegate.cs (DefineDelegate): Make sure the class we define is also sealed.

	(Populate): Define the constructor correctly and set the implementation
	attributes.

	* typemanager.cs (delegate_types): New hashtable to hold delegates that
	have been defined.

	(AddDelegateType): Implement.

	(IsDelegateType): Implement helper method.

	* delegate.cs (DefineDelegate): Use AddDelegateType instead of AddUserType.

	* expression.cs (New::DoResolve): Check if we are trying to instantiate a delegate type
	and accordingly handle it.

	* delegate.cs (Populate): Take TypeContainer argument.
	Implement bits to define the Invoke method. However, I still haven't figured out
	how to take care of the native int bit :-(

	* cs-parser.jay (delegate_declaration): Fixed the bug that I had introduced :-) 
	Qualify the name of the delegate, not its return type !

	* expression.cs (ImplicitReferenceConversion): Implement guts of implicit array
	conversion.

	(StandardConversionExists): Checking for array types turns out to be recursive.

	(ConvertReferenceExplicit): Implement array conversion.

	(ExplicitReferenceConversionExists): New method to determine precisely that :-)
	
2001-10-12  Ravi Pratap  <ravi@ximian.com>

	* cs-parser.jay (delegate_declaration): Store the fully qualified
	name as it is a type declaration.

	* delegate.cs (ReturnType, Name): Rename members to these. Make them 
	readonly.

	(DefineDelegate): Renamed from Define. Does the same thing essentially,
	as TypeContainer::DefineType.

	(Populate): Method in which all the definition of the various methods (Invoke)
	etc is done.

	(Emit): Emit any code, if necessary. I am not sure about this really, but let's
	see.
	
	(CloseDelegate): Finally creates the delegate.

	* class.cs (TypeContainer::DefineType): Update to define delegates.
	(Populate, Emit and CloseType): Do the same thing here too.

	* rootcontext.cs (ResolveTree, PopulateTypes, EmitCode, CloseTypes): Include
	delegates in all these operations.

2001-10-14  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs: LocalTemporary: a new expression used to
	reference a temporary that has been created.

	* assign.cs: Handle PropertyAccess back here, so that we can
	provide the proper semantic access to properties.

	* expression.cs (Expression::ConvertReferenceExplicit): Implement
	a few more explicit conversions. 

	* modifiers.cs: `NEW' modifier maps to HideBySig.

	* expression.cs (PropertyExpr): Make this into an
	ExpressionStatement, and support the EmitStatement code path. 

	Perform get/set error checking, clean up the interface.

	* assign.cs: recognize PropertyExprs as targets, and if so, turn
	them into toplevel access objects.

2001-10-12  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs: PropertyExpr::PropertyExpr: use work around the
	SRE.

	* typemanager.cs: Keep track here of our PropertyBuilders again to
	work around lameness in SRE.

2001-10-11  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (LValue::LValueResolve): New method in the
	interface, used to perform a second resolution pass for LValues. 
	
	(This::DoResolve): Catch the use of this in static methods.

	(This::LValueResolve): Implement.

	(This::Store): Remove warning, assigning to `this' in structures
	is 

	(Invocation::Emit): Deal with invocation of
	methods on value types.  We need to pass the address to structure
	methods rather than the object itself.  (The equivalent code to
	emit "this" for structures leaves the entire structure on the
	stack instead of a pointer to it). 

	(ParameterReference::DoResolve): Compute the real index for the
	argument based on whether the method takes or not a `this' pointer
	(ie, the method is static).

	* codegen.cs (EmitContext::GetTemporaryStorage): Used to store
	value types returned from functions when we need to invoke a
	method on the sturcture.
	

2001-10-11  Ravi Pratap  <ravi@ximian.com>

	* class.cs (TypeContainer::DefineType): Method to actually do the business of
	defining the type in the Modulebuilder or Typebuilder. This is to take
	care of nested types which need to be defined on the TypeBuilder using
	DefineNestedMethod.

	(TypeContainer::GetClassBases): Implement. Essentially the code from the 
	methods in RootContext, only ported to be part of TypeContainer.

	(TypeContainer::GetInterfaceOrClass): Ditto.

	(TypeContainer::LookupInterfaceOrClass, ::MakeFQN): Ditto.

	* interface.cs (Interface::DefineInterface): New method. Does exactly
	what RootContext.CreateInterface did earlier, only it takes care of nested types 
	too.

	(Interface::GetInterfaces): Move from RootContext here and port.

	(Interface::GetInterfaceByName): Same here.

	* rootcontext.cs (ResolveTree): Re-write.

	(PopulateTypes): Re-write.

	* class.cs (TypeContainer::Populate): Populate nested types too.
	(TypeContainer::Emit): Emit nested members too.

	* typemanager.cs (AddUserType): Do not make use of the FullName property,
	instead just use the name argument passed in as it is already fully
	qualified.

	(FindMembers): Check in the Builders to TypeContainer mapping instead of the name
	to TypeContainer mapping to see if a type is user-defined.

	* class.cs (TypeContainer::CloseType): Implement. 

	(TypeContainer::DefineDefaultConstructor): Use Basename, not Name while creating
	the default constructor.
	
	(TypeContainer::Populate): Fix minor bug which led to creating default constructors
	twice.

	(Constructor::IsDefault): Fix up logic to determine if it is the default constructor

	* interface.cs (CloseType): Create the type here.
	
	* rootcontext.cs (CloseTypes): Re-write to recursively close types by running through
	the hierarchy.

	Remove all the methods which are now in TypeContainer.

2001-10-10  Ravi Pratap  <ravi@ximian.com>

	* delegate.cs (Define): Re-write bits to define the delegate
	correctly.

2001-10-10  Miguel de Icaza  <miguel@ximian.com>

	* makefile: Renamed the compiler to `mcs.exe' instead of compiler.exe

	* expression.cs (ImplicitReferenceConversion): handle null as well
	as a source to convert to any reference type.

	* statement.cs (Return): Perform any implicit conversions to
	expected return type.  

	Validate use of return statement.  

	* codegen.cs (EmitContext): Pass the expected return type here.

	* class.cs (Method, Constructor, Property): Pass expected return
	type to EmitContext.

2001-10-09  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs: Make DoResolve take an EmitContext instead of a
	TypeContainer.

	Replaced `l' and `location' for `loc', for consistency.
	
	(Error, Warning): Remove unneeded Tc argument.

	* assign.cs, literal.cs, constant.cs: Update to new calling
	convention. 
	
	* codegen.cs: EmitContext now contains a flag indicating whether
	code is being generated in a static method or not.

	* cs-parser.jay: DecomposeQI, new function that replaces the old
	QualifiedIdentifier.  Now we always decompose the assembled
	strings from qualified_identifier productions into a group of
	memberaccesses.

2001-10-08  Miguel de Icaza  <miguel@ximian.com>

	* rootcontext.cs: Deal with field-less struct types correctly now
	by passing the size option to Define Type.

	* class.cs: Removed hack that created one static field. 

2001-10-07  Miguel de Icaza  <miguel@ximian.com>

	* statement.cs: Moved most of the code generation here. 

2001-10-09  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (New::DoResolve): Revert changes for array creation, doesn't
	seem very right.

	(ElementAccess): Remove useless bits for now - keep checks as the spec
	says.

2001-10-08  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (ElementAccess::DoResolve): Remove my crap code
	and start performing checks according to the spec.

2001-10-07  Ravi Pratap  <ravi@ximian.com>

	* cs-parser.jay (type_suffix*): Remove - they are redundant. Use
	rank_specifiers instead.

	(rank_specifiers): Change the order in which the rank specifiers are stored

	(local_variable_declaration): Use opt_rank_specifier instead of type_suffixes.

	* expression.cs (ElementAccess): Implement the LValue interface too.
	
2001-10-06  Ravi Pratap  <ravi@ximian.com>
	
	* expression.cs (ConvertExplicitStandard): Add. Same as ConvertExplicit
	except that user defined conversions are not included.

	(UserDefinedConversion): Update to use the ConvertExplicitStandard to 
	perform the conversion of the return type, if necessary.

	(New::DoResolve): Check whether we are creating an array or an object
	and accordingly do the needful.

	(New::Emit): Same here.

	(New::DoResolve): Implement guts of array creation.

	(New::FormLookupType): Helper function.

2001-10-07  Miguel de Icaza  <miguel@ximian.com>

	* codegen.cs: Removed most of the code generation here, and move the
	corresponding code generation bits to the statement classes. 

	Added support for try/catch/finalize and throw.
	
	* cs-parser.jay: Added support for try/catch/finalize.

	* class.cs: Catch static methods having the flags override,
	virtual or abstract.

	* expression.cs (UserCast): This user cast was not really doing
	what it was supposed to do.  Which is to be born in fully resolved
	state.  Parts of the resolution were being performed at Emit time! 

	Fixed this code.

2001-10-05  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs: Implicity convert the result from UserCast.

2001-10-05  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (Expression::FindMostEncompassingType): Fix bug which
	prevented it from working correctly. 

	(ConvertExplicit): Make the first try, a call to ConvertImplicitStandard, not
	merely ConvertImplicit.

2001-10-05  Miguel de Icaza  <miguel@ximian.com>

	* typemanager.cs: Make the LookupTypeContainer function static,
	and not per-instance.  

	* class.cs: Make static FindMembers (the one that takes a Type
	argument). 

	* codegen.cs: Add EmitForeach here.

	* cs-parser.jay: Make foreach a toplevel object instead of the
	inline expansion, as we need to perform semantic analysis on it. 

2001-10-05  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (Expression::ImplicitUserConversion): Rename to
	UserDefinedConversion.

	(Expression::UserDefinedConversion): Take an extra argument specifying 
	whether we look for explicit user conversions too.

	(Expression::ImplicitUserConversion): Make it a call to UserDefinedConversion.

	(UserDefinedConversion): Incorporate support for user defined explicit conversions.

	(ExplicitUserConversion): Make it a call to UserDefinedConversion
	with the appropriate arguments.

	* cs-parser.jay (cast_expression): Record location too.

	* expression.cs (Cast): Record location info.

	(Expression::ConvertExplicit): Take location argument.

	(UserImplicitCast): Change name to UserCast. Take an extra constructor argument
	to determine if we are doing explicit conversions.

	(UserCast::Emit): Update accordingly.

	(Expression::ConvertExplicit): Report an error if everything fails.

	* ../errors/cs0030.cs : Add.

2001-10-04  Miguel de Icaza  <miguel@ximian.com>

	* modifiers.cs: If the ABSTRACT keyword is present, also set the
	virtual and newslot bits. 

	* class.cs (TypeContainer::RegisterRequiredImplementations):
	Record methods we need.

	(TypeContainer::MakeKey): Helper function to make keys for
	MethodBases, since the Methodbase key is useless.

	(TypeContainer::Populate): Call RegisterRequiredImplementations
	before defining the methods.   

	Create a mapping for method_builders_to_methods ahead of time
	instead of inside a tight loop.

	(::RequireMethods):  Accept an object as the data to set into the
	hashtable so we can report interface vs abstract method mismatch.

2001-10-03  Miguel de Icaza  <miguel@ximian.com>

	* report.cs: Make all of it static.

	* rootcontext.cs: Drop object_type and value_type computations, as
	we have those in the TypeManager anyways.

	Drop report instance variable too, now it is a global.

	* driver.cs: Use try/catch on command line handling.

	Add --probe option to debug the error reporting system with a test
	suite. 

	* report.cs: Add support for exiting program when a probe
	condition is reached.

2001-10-03  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (Binary::DoNumericPromotions): Fix the case when
	we do a forcible conversion regardless of type, to check if 
	ForceConversion returns a null.

	(Binary::error19): Use location to report error.

	(Unary::error23): Use location here too.

	* ../errors/cs0019.cs : Check in.

	* ../errors/cs0023.cs : Check in.

	* expression.cs (Expression.MemberLookup): Return null for a rather esoteric
	case of a non-null MethodInfo object with a length of 0 !

	(Binary::ResolveOperator): Flag error if overload resolution fails to find
	an applicable member - according to the spec :-)
	Also fix logic to find members in base types.

	(Unary::ResolveOperator): Same here.

	(Unary::report23): Change name to error23 and make first argument a TypeContainer
	as I was getting thoroughly confused between this and error19 :-)
	
	* expression.cs (Expression::ImplicitUserConversion): Re-write fully
	(::FindMostEncompassedType): Implement.
	(::FindMostEncompassingType): Implement.
	(::StandardConversionExists): Implement.

	(UserImplicitCast): Re-vamp. We now need info about most specific
	source and target types so that we can do the necessary conversions.

	(Invocation::MakeUnionSet): Completely re-write to make sure we form a proper
	mathematical union with no duplicates.

2001-10-03  Miguel de Icaza  <miguel@ximian.com>

	* rootcontext.cs (RootContext::PopulateTypes): Populate containers
	in order from base classes to child classes, so that we can in
	child classes look up in our parent for method names and
	attributes (required for handling abstract, virtual, new, override
	constructs: we need to instrospect our base class, and if we dont
	populate the classes in order, the introspection might be
	incorrect.  For example, a method could query its parent before
	the parent has any methods and would determine that the parent has
	no abstract methods (while it could have had them)).

	(RootContext::CreateType): Record the order in which we define the
	classes.

2001-10-02  Miguel de Icaza  <miguel@ximian.com>

	* class.cs (TypeContainer::Populate): Also method definitions can
	fail now, keep track of this.

	(TypeContainer::FindMembers): Implement support for
	DeclaredOnly/noDeclaredOnly flag.

	(Constructor::Emit) Return the ConstructorBuilder.

	(Method::Emit) Return the MethodBuilder. 
	Check for abstract or virtual methods to be public.

	* rootcontext.cs (RootContext::CreateType): Register all the
	abstract methods required for the class to be complete and the
	interface methods that must be implemented. 

	* cs-parser.jay: Report error 501 (method requires body if it is
	not marked abstract or extern).

	* expression.cs (TypeOf::Emit): Implement.

	* typemanager.cs: runtime_handle_type, new global type.

	* class.cs (Property::Emit): Generate code for properties.

2001-10-02  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (Unary::ResolveOperator): Find operators on base type
	too - we now conform exactly to the spec.

	(Binary::ResolveOperator): Same here.

	* class.cs (Operator::Define): Fix minor quirk in the tests.

	* ../errors/cs0215.cs : Added.

	* ../errors/cs0556.cs : Added.

	* ../errors/cs0555.cs : Added.

2001-10-01  Miguel de Icaza  <miguel@ximian.com>

	* cs-tokenizer.cs: Reimplemented Location to be a struct with a
	single integer which is really efficient

2001-10-01  Ravi Pratap  <ravi@ximian.com>

	*  expression.cs (Expression::ImplicitUserConversion): Use location
        even in the case when we are examining True operators.
 
        * class.cs (Operator::Define): Perform extensive checks to conform
        with the rules for operator overloading in the spec.

	* expression.cs (Expression::ImplicitReferenceConversion): Implement
	some of the other conversions mentioned in the spec.

	* typemanager.cs (array_type): New static member for the System.Array built-in
	type.

	(cloneable_interface): For System.ICloneable interface.

	* driver.cs (Driver::Driver): Initialize TypeManager's core types even before
	we start resolving the tree and populating types.

	* ../errors/errors.txt : Update for error numbers -7, -8, -9, -10
 
2001-10-01  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (Expression::ExprClassFromMemberInfo,
	Expression::Literalize): Create literal expressions from
	FieldInfos which are literals.

	(ConvertNumericExplicit, ImplicitNumericConversion): Fix a few
	type casts, because they were wrong.  The test suite in tests
	caught these ones.

	(ImplicitNumericConversion): ushort to ulong requires a widening
	cast. 

	Int32 constant to long requires widening cast as well.

	* literal.cs (LongLiteral::EmitLong): Do not generate i4 constants
	for integers because the type on the stack is not i4.

2001-09-30  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (report118): require location argument. 

	* parameter.cs: Do not dereference potential null value.

	* class.cs: Catch methods that lack the `new' keyword when
	overriding a name.  Report warnings when `new' is used without
	anything being there to override.

	* modifiers.cs: Handle `NEW' as MethodAttributes.NewSlot.

	* class.cs: Only add constructor to hashtable if it is non-null
	(as now constructors can fail on define).

	(TypeManager, Class, Struct): Take location arguments.

	Catch field instance initialization in structs as errors.

	accepting_filter: a new filter for FindMembers that is static so
	that we dont create an instance per invocation.

	(Constructor::Define): Catch errors where a struct constructor is
	parameterless 

	* cs-parser.jay: Pass location information for various new
	constructs. 
	
	* delegate.cs (Delegate): take a location argument.

	* driver.cs: Do not call EmitCode if there were problesm in the
	Definition of the types, as many Builders wont be there. 

	* decl.cs (Decl::Decl): Require a location argument.

	* cs-tokenizer.cs: Handle properly hex constants that can not fit
	into integers, and find the most appropiate integer for it.

	* literal.cs: Implement ULongLiteral.

	* rootcontext.cs: Provide better information about the location of
	failure when CreateType fails.
	
2001-09-29  Miguel de Icaza  <miguel@ximian.com>

	* rootcontext.cs (RootContext::PopulateTypes): Populates structs
	as well.

	* expression.cs (Binary::CheckShiftArguments): Add missing type
	computation.
	(Binary::ResolveOperator): Add type to the logical and and logical
	or, Bitwise And/Or and Exclusive Or code paths, it was missing
	before.

	(Binary::DoNumericPromotions): In the case where either argument
	is ulong (and most signed types combined with ulong cause an
	error) perform implicit integer constant conversions as well.

2001-09-28  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (UserImplicitCast): Method should always be
	non-null. 
	(Invocation::BetterConversion): Simplified test for IntLiteral.

	(Expression::ImplicitNumericConversion): Split this routine out.
	Put the code that performs implicit constant integer conversions
	here. 

	(Expression::Resolve): Become a wrapper around DoResolve so we can
	check eclass and type being set after resolve.

	(Invocation::Badness): Remove this dead function

	(Binary::ResolveOperator): Do not compute the expensive argumnets
	unless we have a union for it.

	(Probe::Emit): Is needs to do an isinst and then
	compare against null.

	(::CanConvert): Added Location argument.  If the Location argument
	is null (Location.Null), then we do not report errors.  This is
	used by the `probe' mechanism of the Explicit conversion.  We do
	not want to generate an error for something that the user
	explicitly requested to be casted.  But the pipeline for an
	explicit cast first tests for potential implicit casts.

	So for now, if the Location is null, it means `Probe only' to
	avoid adding another argument.   Might have to revise this
	strategy later.

	(ClassCast): New class used to type cast objects into arbitrary
	classes (used in Explicit Reference Conversions).

	Implement `as' as well.

	Reverted all the patches from Ravi below: they were broken:

		* The use of `level' as a mechanism to stop recursive
		  invocations is wrong.  That was there just to catch the
		  bug with a strack trace but not as a way of addressing
		  the problem.

		  To fix the problem we have to *understand* what is going
		  on and the interactions and come up with a plan, not
		  just get things going.

		* The use of the type conversion cache that I proposed
		  last night had an open topic: How does this work across
		  protection domains.  A user defined conversion might not
		  be public in the location where we are applying the
		  conversion, a different conversion might be selected
		  (ie, private A->B (better) but public B->A (worse),
		  inside A, A->B applies, but outside it, B->A will
		  apply).

		* On top of that (ie, even if the above is solved),
		  conversions in a cache need to be abstract.  Ie, `To
		  convert from an Int to a Short use an OpcodeCast', not
		  `To convert from an Int to a Short use the OpcodeCast on
		  the variable 5' (which is what this patch was doing).
	
2001-09-28  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (Invocation::ConversionExists): Re-write to use
	the conversion cache
	
	(Expression::ConvertImplicit): Automatic bailing out if level != 0. Also
	cache all conversions done, not just user-defined ones.

	(Invocation::BetterConversion): The real culprit. Use ConversionExists
	to determine if a conversion exists instead of acutually trying to 
	perform the conversion. It's faster too.

	(Expression::ConvertExplicit): Modify to use ConversionExists to check
	and only then attempt the implicit conversion.

2001-09-28  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (ConvertImplicit): Use a cache for conversions
	already found. Check level of recursion and bail out if necessary.
	
2001-09-28  Miguel de Icaza  <miguel@ximian.com>

	* typemanager.cs (string_concat_string_string, string_concat_object_object):
	Export standard methods that we expect for string operations.
	
	* statement.cs (Block::UsageWarning): Track usage of variables and
	report the errors for not used variables.

	* expression.cs (Conditional::Resolve, ::Emit): Implement ?:
	operator. 

2001-09-27  Miguel de Icaza  <miguel@ximian.com>

	* codegen.cs: remove unnneded code 

	* expression.cs: Removed BuiltinTypeAccess class

	Fix the order in which implicit conversions are
	done.  

	The previous fixed dropped support for boxed conversions (adding a
	test to the test suite now)

	(UserImplicitCast::CanConvert): Remove test for source being null,
	that code is broken.  We should not feed a null to begin with, if
	we do, then we should track the bug where the problem originates
	and not try to cover it up here.

	Return a resolved expression of type UserImplicitCast on success
	rather than true/false.  Ravi: this is what I was talking about,
	the pattern is to use a static method as a "constructor" for
	objects. 

	Also, do not create arguments until the very last minute,
	otherwise we always create the arguments even for lookups that
	will never be performed. 

	(UserImplicitCast::Resolve): Eliminate, objects of type
	UserImplicitCast are born in a fully resolved state. 
	
	* typemanager.cs (InitCoreTypes): Init also value_type
	(System.ValueType). 

	* expression.cs (Cast::Resolve): First resolve the child expression.

	(LValue): Add new method AddressOf to be used by
	the `&' operator.  

	Change the argument of Store to take an EmitContext instead of an
	ILGenerator, because things like FieldExpr need to be able to call
	their children expression to generate the instance code. 

	(Expression::Error, Expression::Warning): Sugar functions for
	reporting errors.

	(Expression::MemberLookup): Accept a TypeContainer instead of a
	Report as the first argument.

	(Expression::ResolvePrimary): Killed.  I still want to improve
	this as currently the code is just not right.

	(Expression::ResolveMemberAccess): Simplify, but it is still
	wrong. 

	(Unary::Resolve): Catch errors in AddressOf operators.

	(LocalVariableReference::Emit, ::Store, ::AddressOf): typecast
	index to a byte for the short-version, or the compiler will choose
	the wrong Emit call, which generates the wrong data.

	(ParameterReference::Emit, ::Store): same.

	(FieldExpr::AddressOf): Implement.
	
	* typemanager.cs: TypeManager: made public variable instead of
	property.
	
	* driver.cs: document --fatal.

	* report.cs (ErrorMessage, WarningMessage): new names for the old
	Error and Warning classes.

	* cs-parser.jay (member_access): Turn built-in access to types
	into a normal simplename

2001-09-27  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (Invocation::BetterConversion): Fix to cope
	with q being null, since this was introducing a bug.

	* expression.cs (ConvertImplicit): Do built-in conversions first.

2001-09-27  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (UserImplicitCast::Resolve): Fix bug.

2001-09-27  Ravi Pratap  <ravi@ximian.com>

	* class.cs (TypeContainer::AddConstructor): Fix a stupid bug
	I had introduced long ago (what's new ?).

	* expression.cs (UserImplicitCast::CanConvert): Static method to do 
	the work of all the checking. 
	(ConvertImplicit): Call CanConvert and only then create object if necessary.
	(UserImplicitCast::CanConvert, ::Resolve): Re-write.

	(Unary::Operator): Rename Add and Subtract to Addition and Subtraction because
	that is the right way. 

	(Invocation::MakeUnionSet): Convenience function to make unions of sets for 
	overloading resolution. Use everywhere instead of cutting and pasting code.

	(Binary::ResolveOperator): Use MakeUnionSet.

	(UserImplicitCast::CanConvert, ::Resolve): Update to take care of the case when 
	we have to convert to bool types. Not complete yet.
	
2001-09-27  Miguel de Icaza  <miguel@ximian.com>

	* typemanager.cs (TypeManager::CSharpName): support ushort.

	* expression.cs (Expression::TryImplicitIntConversion): Attempts
	to provide an expression that performsn an implicit constant int
	conversion (section 6.1.6).
	(Expression::ConvertImplicitRequired): Reworked to include
	implicit constant expression conversions.

	(Expression::ConvertNumericExplicit): Finished.

	(Invocation::Emit): If InstanceExpression is null, then it means
	that we perform a call on this.
	
2001-09-26  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (Unary::Emit): Remove some dead code.
	(Probe): Implement Resolve and Emit for `is'.
	(Expression::ConvertImplicitRequired): Attempt to do constant
	expression conversions here.  Maybe should be moved to
	ConvertImplicit, but I am not sure.
	(Expression::ImplicitLongConstantConversionPossible,
	Expression::ImplicitIntConstantConversionPossible): New functions
	that tell whether is it possible to apply an implicit constant
	expression conversion.

	(ConvertNumericExplicit): Started work on explicit numeric
	conversions.

	* cs-parser.jay: Update operator constants.

	* parameter.cs (Parameters::GetParameterInfo): Hook up VerifyArgs
	(Parameters::GetSignature): Hook up VerifyArgs here.
	(Parameters::VerifyArgs): Verifies that no two arguments have the
	same name. 

	* class.cs (Operator): Update the operator names to reflect the
	ones that the spec expects (as we are just stringizing the
	operator names).
	
	* expression.cs (Unary::ResolveOperator): Fix bug: Use
	MethodInfo's ReturnType instead of LookupMethodByBuilder as the
	previous usage did only work for our methods.
	(Expression::ConvertImplicit): Handle decimal implicit numeric
	conversions as well.
	(Expression::InternalTypeConstructor): Used to invoke constructors
	on internal types for default promotions.

	(Unary::Emit): Implement special handling for the pre/post
	increment/decrement for overloaded operators, as they need to have
	the same semantics as the other operators.

	(Binary::ResolveOperator): ditto.
	(Invocation::ConversionExists): ditto.
	(UserImplicitCast::Resolve): ditto.
	
2001-09-26  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (Unary::Emit and Binary::Emit): If we have an overloaded
	operator, return after emitting body. Regression tests pass again !

	* expression.cs (ConvertImplicit): Take TypeContainer as first argument
	(Unary::ForceConversion, Binary::ForceConversion): Ditto.
	(Invocation::OverloadResolve): Ditto.
	(Invocation::BetterFunction, BetterConversion, ConversionExists): Ditto.

	* everywhere : update calls to the above methods accordingly.

2001-09-26  Miguel de Icaza  <miguel@ximian.com>

	* assign.cs (Assign): Make it inherit from ExpressionStatement.

	* expression.cs (ExpressionStatement): New base class used for
	expressions that can appear in statements, so that we can provide
	an alternate path to generate expression that do not leave a value
	on the stack.

	(Expression::Emit, and all the derivatives): We no longer return
	whether a value is left on the stack or not.  Every expression
	after being emitted leaves a single value on the stack.

	* codegen.cs (EmitContext::EmitStatementExpression): Use the
	facilties of ExpressionStatement if possible.

	* cs-parser.jay: Update statement_expression.

2001-09-25  Miguel de Icaza  <miguel@ximian.com>

	* driver.cs: Change the wording of message

2001-09-25  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (Binary::ResolveOperator): Had forgottten to set 
	the type of the expression to the return type of the method if
	we have an overloaded operator match ! The regression tests pass again !
	(Unary::ResolveOperator): Ditto.

	* expression.cs (Invocation::ConversionExists): Correct the member lookup
	to find "op_Implicit", not "implicit" ;-)
	(UserImplicitCast): New class to take care of user-defined implicit conversions.
	(ConvertImplicit, ForceConversion): Take TypeContainer argument

	* everywhere : Correct calls to the above accordingly.

	* expression.cs (UserImplicitCast::Resolve, ::Emit): Implement.
	(ConvertImplicit): Do user-defined conversion if it exists.

2001-09-24  Miguel de Icaza  <miguel@ximian.com>

	* assign.cs: track location.
	(Resolve): Use implicit conversions on assignment.

	* literal.cs: Oops.  Not good, Emit of short access values should
	pass (Bytes) or the wrong argument will be selected.

	* expression.cs (Unary::Emit): Emit code for -expr.
	
	(Unary::ResolveOperator): Handle `Substract' for non-constants
	(substract from zero from the non-constants).
	Deal with Doubles as well. 
	
	(Expression::ConvertImplicitRequired): New routine that reports an
	error if no implicit conversion exists. 

	(Invocation::OverloadResolve): Store the converted implicit
	expressions if we make them
	
2001-09-24  Ravi Pratap  <ravi@ximian.com>

	* class.cs (ConstructorInitializer): Take a Location argument.
	(ConstructorBaseInitializer): Same here.
	(ConstructorThisInitializer): Same here.

	* cs-parser.jay : Update all calls accordingly.

	* expression.cs (Unary, Binary, New): Take location argument.
	Update accordingly everywhere.

	* cs-parser.jay : Update all calls to the above to take a location
	argument.

	* class.cs : Ditto.

2001-09-24  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (Invocation::BetterFunction): Take TypeContainer argument
	(Invocation::BetterConversion): Same here
	(Invocation::ConversionExists): Ditto.

	(Invocation::ConversionExists): Implement.

2001-09-22  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (OverloadResolve): Improve some more to catch errors 1502 and 1503
	Also take an additional TypeContainer argument.

	* All over : Pass in TypeContainer as argument to OverloadResolve.

	* typemanager.cs (CSharpName): Update to check for the string type and return
	that too.

	* expression.cs (Invocation::FullMethodDesc): New static method to return a string fully describing
	a given method.
	
2001-09-21  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (Invocation::OverloadResolve): Re-write to conform more to the spec.
	(Invocation::BetterFunction): Implement.
	(Invocation::BetterConversion): Implement.
	(Invocation::ConversionExists): Skeleton, no implementation yet.

	Okay, things work fine !

2001-09-21  Miguel de Icaza  <miguel@ximian.com>

	* typemanager.cs: declare and load enum_type, delegate_type and
	void_type. 

	* expression.cs (Expression::Emit): Now emit returns a value that
	tells whether a value is left on the stack or not.  This strategy
	might be reveted tomorrow with a mechanism that would address
	multiple assignments.
	(Expression::report118): Utility routine to report mismatches on
	the ExprClass.

	(Unary::Report23): Report impossible type/operator combination
	utility function.

	(Unary::IsIncrementableNumber): Whether the type can be
	incremented or decremented with add.
	(Unary::ResolveOperator): Also allow enumerations to be bitwise
	complemented. 
	(Unary::ResolveOperator): Implement ++, !, ~, ++ and --.

	(Invocation::Emit): Deal with new Emit convetion.
	
	* All Expression derivatives: Updated their Emit method to return
	whether they leave values on the stack or not.
	
	* codegen.cs (CodeGen::EmitStatement): Pop values left on the
	stack for expressions that are statements. 

2001-09-20  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (LValue): New interface.  Must be implemented by
	LValue objects.
	(LocalVariableReference, ParameterReference, FieldExpr): Implement
	LValue interface.
	
	* assign.cs (Assign::Emit, Assign::Resolve): Use new LValue
	interface for generating code, simplifies the code.

2001-09-20  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (everywhere): Comment out return statements in ::Resolve
	methods to avoid the warnings.

2001-09-20  Miguel de Icaza  <miguel@ximian.com>

	* driver.cs (parse): Report error 2001 if we can not open the
	source file.

	* expression.cs (SimpleName::ResolveSimpleName): Error if we can
	not resolve it.

	* cs-parser.jay (QualifierIdentifier): Pass location to SimpleName
	object. 

	* statement.cs (Block::EmitMeta): Reuse the count across all the variables,
	otherwise nested blocks end up with the same index.

	* codegen.cs (CodeGen::EmitTopBlock): Pass initial sequence

	* expression.cs:  Instead of having FIXMEs in the Resolve
	functions, throw exceptions so it is obvious that we are facing a
	bug. 

	* cs-parser.jay (invocation_expression): Pass Location information.

	* codegen.cs (CodeGen::Save, CodeGen::CodeGen, CodeGen::Basename):
	Use a basename for those routines because .NET does not like paths
	on them. 

	* class.cs (TypeContainer::AddMethod): Do not call DefineName if the name was
	already defined.

2001-09-19  Miguel de Icaza  <miguel@ximian.com>

	* typemanager.cs (TypeManager::CoreLookupType): A function to make sure that we
	are loading the correct data types (throws an exception if not).
	(TypeManager::InitCoreTypes): Use CoreLookupType

	* expression.cs (Unary::ResolveOperator): return the child
	expression for expressions which are just +expr.
	(Unary::ResolveOperator): Return negative literals for -LITERAL
	expressions (otherwise they are Unary {Literal}).
	(Invocation::Badness): Take into account `Implicit constant
	expression conversions'.

	* literal.cs (LongLiteral): Implement long literal class.
	(IntLiteral): export the `Value' of the intliteral. 

2001-09-19  Ravi Pratap  <ravi@ximian.com>

	* expression.cs (Binary::Emit): Finally get the emission right ! Woo!

	* class.cs (Operator::Define): Change the methodname prefix to 'op_' 
	instead of 'Operator'

	* expression.cs (Binary::ResolveOperator): Update accordingly.
	(Unary::Operator): Change names to 'Add' and 'Subtract' instead 'Plus'
	and 'Minus'

	* cs-parser.jay (unary_expression): Update to use the new names.

	* gen-treedump.cs (GetUnary): Same here.

	* expression.cs (Unary::Resolve): Implement.
	(Binary::ResolveOperator): Re-write bits to quietly continue if no overloaded 
	operators are found instead of making noise ;-)
	(Unary::ResolveOperator): New method to do precisely the same thing which
	Binary::ResolveOperator does for Binary expressions.
	(Unary.method, .Arguments): Add.
	(Unary::OperName): Implement.	
	(Unary::ForceConversion): Copy and Paste !

	* class.cs (Operator::Define): Fix a small bug for the case when we have 
	a unary operator.

	* expression.cs (Unary::Emit): Implement. Need to find the right Opcodes
	for the inbuilt operators. Only overloading works for now ;-)

2001-09-18  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (CheckedExpr::Resolve, CheckedExpr::Emit,
	UnCheckedExpr::Resolve, UnCheckedExpr::Emit): Implement.

	* expression.cs (This::Emit): Implement. 
	(This::Resolve): Implement.
	(TypeOf:Resolve): Implement.
	(Expression::ResolveSimpleName): Add an implicit this to instance
	field references. 
	(MemberAccess::Resolve): Deal with Parameters and Fields. 
	Bind instance variable to Field expressions.
	(FieldExpr::Instance): New field used to track the expression that
	represents the object instance.
	(FieldExpr::Resolve): Track potential errors from MemberLookup not
	binding 
	(FieldExpr::Emit): Implement.

	* codegen.cs (EmitIf, EmitStatement, EmitBlock): Propagate whether
	the last instruction contains a return opcode to avoid generating
	the last `ret' instruction (this generates correct code, and it is
	nice to pass the peverify output).

	* class.cs (TypeContainer::EmitFieldInitializers): Implement field
	initializer for static and instance variables.
	(Constructor::Emit): Allow initializer to be null in the case of
	static constructors.  Only emit initializer for instance
	constructors. 

	(TypeContainer::FindMembers): Return a null array if there are no
	matches.

	Also fix the code for the MemberTypes.Method branch, as it was not
	scanning that for operators (or tried to access null variables before).

	* assign.cs (Assign::Emit): Handle instance and static fields. 

	* TODO: Updated.

	* driver.cs: Stop compilation if there are parse errors.

	* cs-parser.jay (constructor_declaration): Provide default base
	initializer for non-static constructors.
	(constructor_declarator): Do not provide a default base
	initializers if none was specified.
	Catch the fact that constructors should not have parameters.

	* class.cs: Do not emit parent class initializers for static
	constructors, that should be flagged as an error.

2001-09-18  Ravi Pratap  <ravi@ximian.com>

	* class.cs (RegisterMethodBuilder): Remove : it's unnecessary.
	Move back code into TypeContainer::Populate.

2001-09-18  Ravi Pratap  <ravi@ximian.com>

	* class.cs (TypeContainer::AddConstructor): Fix the check to
	compare against Name, not Basename. 
	(Operator::OpType): Change Plus and Minus to Add and Subtract.

	* cs-parser.jay : Update accordingly.

	* class.cs (TypeContainer::FindMembers): For the case where we are searching
	for methods, don't forget to look into the operators too.
	(RegisterMethodBuilder): Helper method to take care of this for
	methods, constructors and operators.
	(Operator::Define): Completely revamp.
	(Operator.OperatorMethod, MethodName): New fields.
	(TypeContainer::Populate): Move the registering of builders into
	RegisterMethodBuilder.
	(Operator::Emit): Re-write.

	* expression.cs (Binary::Emit): Comment out code path to emit method
	invocation stuff for the case when we have a user defined operator. I am
	just not able to get it right !
	
2001-09-17  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (Expression::OverloadResolve): Drop TypeContainer
	argument. 

	(Expression::MemberLookup): Provide a version that allows to
	specify the MemberTypes and BindingFlags. 

	* statement.cs (Block::GetVariableInfo): Forgot to recurse here,
	so it was not fetching variable information from outer blocks.

	* modifiers.cs: (Modifiers::TypeAttr): Invert condition on
	Beforefieldinit as it was buggy.

	* rootcontext.cs (::LookupInterfaceOrClass): Removed an Error -200
	that Ravi put here.  

	* class.cs (Constructor::Emit): Only emit if block is not null.
	(TypeContainer::EmitDefaultConstructor): Removed routine, now we
	deal with this by semantically definining it as if the user had
	done it.

	(TypeContainer::FindMembers): Removed ad-hoc hack to deal with
	constructors as we now "emit" them at a higher level.

	(TypeContainer::DefineDefaultConstructor): Used to define the
	default constructors if none was provided.

	(ConstructorInitializer): Add methods Resolve and Emit. 
	
	* expression.cs: Cast to ConstructorInfo instead of MethodInfo

2001-09-17  Ravi Pratap  <ravi@ximian.com>

	* class.cs (TypeContainer::EmitDefaultConstructor): Register
	the default constructor builder with our hashtable for methodbuilders
	to methodcores.

	* expression.cs (Invocation::OverloadResolve): Add a check for pd == null
	and argument_count is 0 in which case we have a match.
	(Binary::ResolveOperator): More null checking and miscellaneous coding
	style cleanup.

2001-09-17  Ravi Pratap  <ravi@ximian.com>

	* rootcontext.cs (IsNameSpace): Compare against null.

	* everywhere : Correct spelling to 'Greater' and to 'Subtract'

	* class.cs (Operator::OpType): Change names to match the ones in Binary::Operator
	and Unary::Operator.

	* cs-parser.jay (operator_declaration, CheckBinaryOperator, CheckUnaryOperator): Update
	accordingly.

	* expression.cs (Binary::method): New member to hold the MethodBase for the case when
	we have overloaded operators.
	(Binary::ResolveOperator): Implement the part which does the operator overload
	resolution.

	* class.cs (Operator::Emit): Implement.
	(TypeContainer::Emit): Emit the operators we have too.

	* expression.cs (Binary::Emit): Update to emit the appropriate code for
	the case when we have a user-defined operator.
	
2001-09-17  Miguel de Icaza  <miguel@ximian.com>

	* rootcontext.cs: Fix bug: tree.Namespaces might be null.

2001-09-16  Ravi Pratap  <ravi@ximian.com>

	* class.cs (EmitStaticFieldInitializers, EmitFieldInitializers): Make public.
	(TypeContainer::EmitConstructor): Remove and move code into Contructor::Emit.
	(Constructor::Emit): Implement.
	(EmitStaticFieldInitializers, EmitFieldInitializers): Ensure we return immediately
	if we have no work to do. 
	(TypeContainer::Emit): Pass in TypeContainer as argument to the constructor's 
	Emit method.

	* interface.cs (Interface::InterfaceAttr): Re-write to be more correct and complete.
	(Interface::IsTopLevel): Add. Same as TypeContainer::IsTopLevel.

	* class.cs (TypeContainer::IsTopLevel): Modify to use parent.Parent instead
	of parent.parent.

2001-09-15  Ravi Pratap  <ravi@ximian.com>

	* tree.cs (Tree::namespaces): New hashtable to keep track of namespaces
	in the source.
	(Tree::RecordNamespace): Method to do what the name says ;-)
	(Tree::Namespaces): Property to get at the namespaces hashtable.

	* cs-parser.jay (namespace_declaration): Call RecordNamespace to 
	keep track.

	* rootcontext.cs (IsNamespace): Fixed it :-)

2001-09-14  Miguel de Icaza  <miguel@ximian.com>

	* class.cs (TypeContainer::FindMembers): Add support for
	constructors. 
	(MethodCore): New class that encapsulates both the shared aspects
	of a Constructor and a Method.  
	(Method, Constructor): Factored pieces into MethodCore.

	* driver.cs: Added --fatal which makes errors throw exceptions.
	Load System assembly as well as part of the standard library.

	* report.cs: Allow throwing exceptions on errors for debugging.

	* modifiers.cs: Do not use `parent', instead use the real type
	container to evaluate permission settings.

	* class.cs: Put Ravi's patch back in.  He is right, and we will
	have to cope with the

2001-09-14  Ravi Pratap  <ravi@ximian.com>

	* modifiers.cs (TypeAttr, MethodAttr, FieldAttr): Map protected internal to
	FamORAssem, not FamANDAssem.
	
2001-09-14  Miguel de Icaza  <miguel@ximian.com>

	* driver.cs: Added --parse option that only parses its input files
	and terminates.

	* class.cs: Reverted last change from Ravi to IsTopLevel.  That is
	incorrect.  IsTopLevel is not used to tell whether an object is
	root_types or not (that can be achieved by testing this ==
	root_types).  But to see if this is a top-level *class* (not
	necessarly our "toplevel" container). 

2001-09-14  Ravi Pratap  <ravi@ximian.com>

	* enum.cs (Enum::Define): Modify to call the Lookup method on the
	parent instead of a direct call to GetType.

2001-09-14  Ravi Pratap  <ravi@ximian.com>

	* class.cs (TypeContainer::TypeAttr): Remove property code and move it into
	Modifiers.TypeAttr. This should just be a call to that method.

	* modifiers.cs (TypeAttr): Re-write and take an extra argument, the TypeContainer
	object so that we can determine if we are top-level or not.

	* delegate.cs (Delegate::Define): Update call to TypeAttr method to pass in the 
	TypeContainer too.

	* enum.cs (Enum::Define): Ditto.

	* modifiers.cs (FieldAttr): Re-write.

	* class.cs (TypeContainer::IsTopLevel): Change accessibility to public.
	(TypeContainer::HaveStaticConstructor): New property to provide access
	to precisely that info.

	* modifiers.cs (MethodAttr): Re-write.
	(EventAttr): Remove altogether as there seems to be no ostensible use for it.

	* class.cs (TypeContainer::IsTopLevel): Re-write. root_types doesn't seem to be the parent
	of top-level types as claimed.
	
2001-09-13  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (MemberLookup): Fruitless attempt to lookup
	constructors.  Maybe I need to emit default constructors?  That
	might be it (currently .NET emits this for me automatically).
	(Invocation::OverloadResolve): Cope with Arguments == null.
	(Invocation::EmitArguments): new function, shared by the new
	constructor and us.
	(Invocation::Emit): Handle static and instance methods.  Emit
	proper call instruction for virtual or non-virtual invocations.
	(New::Emit): Implement.
	(New::Resolve): Implement.
	(MemberAccess:Resolve): Implement.
	(MethodGroupExpr::InstanceExpression): used conforming to the spec
	to track instances.
	(FieldExpr::Resolve): Set type.

	* support.cs: Handle empty arguments.
		
	* cs-parser.jay (CompositeLookup, QualifierIdentifier,
	SimpleLookup): Auxiliary routines to help parse a qualifier
	identifier.  

	Update qualifier_identifier rule.

	* codegen.cs: Removed debugging messages.

	* class.cs: Make this a global thing, this acts just as a "key" to
	objects that we might have around.

	(Populate): Only initialize method_builders_to_methods once.

	* expression.cs (PropertyExpr): Initialize type from the
	PropertyType. 

	* codegen.cs (EmitContext::EmitBoolExpression): Use propper
	Resolve pattern.  Attempt to implicitly convert value to boolean.
	Emit code.

	* expression.cs: Set the type for the int32/int32 argument case.
	(Binary::ResolveOperator): Set the return type to boolean for
	comparission operators

	* typemanager.cs: Remove debugging print code.

	(Invocation::Resolve): resolve type.

	* class.cs: Allocate a MemberInfo of the correct size, as the code
	elsewhere depends on the test to reflect the correct contents.

	(Method::) Keep track of parameters, due to System.Reflection holes

	(TypeContainer::Populate): Keep track of MethodBuilders to Method
	mapping here.

	(TypeContainer::FindMembers): Use ArrayList and then copy an array
	of the exact size and return that.

	(Class::LookupMethodByBuilder): New function that maps
	MethodBuilders to its methods.  Required to locate the information
	on methods because System.Reflection bit us again.

	* support.cs: New file, contains an interface ParameterData and
	two implementations: ReflectionParameters and InternalParameters
	used to access Parameter information.  We will need to grow this
	as required.

	* expression.cs (Invocation::GetParameterData): implement a cache
	and a wrapper around the ParameterData creation for methods. 
	(Invocation::OverloadResolve): Use new code.

2001-09-13  Ravi Pratap  <ravi@ximian.com>

	* class.cs (TypeContainer::EmitField): Remove and move into 
	(Field::Define): here and modify accordingly.
	(Field.FieldBuilder): New member.
	(TypeContainer::Populate): Update accordingly.
	(TypeContainer::FindMembers): Implement.

2001-09-13  Miguel de Icaza  <miguel@ximian.com>

	* statement.cs: (VariableInfo::VariableType): New field to be
	initialized with the full type once it is resolved. 

2001-09-12  Miguel de Icaza  <miguel@ximian.com>

	* parameter.cs (GetParameterInfo): Use a type cache to compute
	things only once, and to reuse this information

	* expression.cs (LocalVariableReference::Emit): Implement.
	(OpcodeCast::Emit): fix.

	(ParameterReference::Resolve): Implement.
	(ParameterReference::Emit): Implement.

	* cs-parser.jay: Fix bug introduced by Ravi, variable initializers
	that are expressions need to stay as Expressions.

	* typemanager.cs (CSharpName): Returns the C# name of a type if
	possible. 

	* expression.cs (Expression::ConvertImplicit): New function that
	implements implicit type conversions.

	(Expression::ImplicitReferenceConversion): Implements implicit
	reference conversions.

	(EmptyCast): New type for transparent casts.

	(OpcodeCast): New type for casts of types that are performed with
	a sequence of bytecodes.
	
	(BoxedCast): New type used for casting value types into reference
	types.  Emits a box opcode.

	(Binary::DoNumericPromotions): Implements numeric promotions of
	and computation of the Binary::Type.

	(Binary::EmitBranchable): Optimization.

	(Binary::Emit): Implement code emission for expressions.
	
	* typemanager.cs (TypeManager): Added two new core types: sbyte
	and byte.

2001-09-12  Ravi Pratap  <ravi@ximian.com>

	* class.cs (TypeContainer::FindMembers): Method which does exactly
	what Type.FindMembers does, only we don't have to use reflection. No
	implementation yet.

	* typemanager.cs (typecontainers): New hashtable to hold the corresponding
	typecontainer objects as we need to get at them.
	(TypeManager::AddUserType): Overload to take an extra argument, the TypeContainer.

	* rootcontext.cs : Correspondingly modify called to AddUserType to pass the
	typecontainer object.

	* expression.cs (MemberLookup): Modify signature to take a RootContext object instead
	of just a Report object.

2001-09-11  Ravi Pratap  <ravi@ximian.com>

	* class.cs (Event::Define): Go back to using the prefixes "add_" and
	"remove_"
	(TypeContainer::Populate): Now define the delegates of the type too.
	(TypeContainer.Delegates): Property to access the list of delegates defined
	in the type.

	* delegates.cs (Delegate::Define): Implement partially.

	* modifiers.cs (TypeAttr): Handle more flags.

2001-09-11  Ravi Pratap  <ravi@ximian.com>

	* class.cs (Indexer::Define): Fix for loop iteration condition to be just <
	and not <=
	(Operator::Define): Re-write logic to get types by using the LookupType method
	instead of blindly doing a Type.GetType ! How stupid can I get ;-) ?
 	(Indexer::Define): Ditto.
	(Event::Define): Ditto.
	(Property::Define): Ditto.
	
2001-09-10  Ravi Pratap  <ravi@ximian.com>

	* class.cs (TypeContainer::Populate): Now define operators too. 
	(TypeContainer.Operators): New property to access the list of operators
	in a type.
	(Operator.OperatorMethodBuilder): New member to hold the method builder
	for the operator we are defining.
	(Operator::Define): Implement.

2001-09-10  Ravi Pratap  <ravi@ximian.com>

	* class.cs (Event::Define): Make the prefixes of the accessor methods
	addOn_ and removeOn_ 

	* genericparser.cs (GenericParser::error): Overloaded method to handle the case
	of the location being passed in too. Ideally, this should go later since all
	error reporting should be done through the Report object.

	* class.cs (TypeContainer.Indexers): New property to access the list of indexers.
	(Populate): Iterate thru the indexers we have and define them too.
	(Indexer.GetMethodBuilder, .SetMethodBuilder): New members to hold the method builders
	for the get and set accessors.
	(Indexer::Define): Implement.
	
2001-09-09  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (Binary::Resolve): Beginning of it.  I scratched
	my previous implementation, did not work.

	* typemanager.cs: Add a couple of missing types (the longs).

	* literal.cs: Use TypeManager.bool_type instead of getting it.

	* expression.cs (EventExpr): New kind of expressions.
	(Expressio::ExprClassFromMemberInfo): finish

2001-09-08  Miguel de Icaza  <miguel@ximian.com>

	* assign.cs: Emit stores to static fields differently.

2001-09-08  Ravi Pratap  <ravi@ximian.com>

	* Merge in changes and adjust code to tackle conflicts. Backed out my
	code in Assign::Resolve ;-) 

2001-09-08  Ravi Pratap  <ravi@ximian.com>

	* cs-parser.jay (CheckAttributeTarget): Modify call to error to use
	instead Report.Error and also pass in the location.
	(CSharpParser::Lexer): New readonly property to return the reference
	to the Tokenizer object.
	(declare_local_variables): Use Report.Error with location instead of plain 
	old error.
	(CheckDef): Ditto.

	* class.cs (Operator::CheckUnaryOperator): Move into cs-parser.jay.
	(Operator.CheckBinaryOperator): Ditto.

	* cs-parser.jay (operator_declarator): Update accordingly.

	* cs-parser.jay (CheckUnaryOperator): Modify to use Report.Error
	(CheckBinaryOperator): Same here.

	* rootcontext.cs (LookupType): Add an extra lookup which simply does a lookup
	on the name without any prefixes of namespace names etc. This is because we
	already might have something already fully qualified like 
	'System.Console.WriteLine'

	* assign.cs (Resolve): Begin implementation. Stuck ;-)

2001-09-07  Ravi Pratap  <ravi@ximian.com>

	* cs-tokenizer.cs (location): Return a string which also contains
	the file name.

	* expression.cs (ElementAccess): New class for expressions of the
	type 'element access.'
	(BaseAccess): New class for expressions of the type 'base access.'
	(CheckedExpr, UnCheckedExpr): New classes for Checked and Unchecked expressions
	respectively.
	
	* cs-parser.jay (element_access): Implement action.
	(base_access): Implement actions.
	(checked_expression, unchecked_expression): Implement.

	* cs-parser.jay (local_variable_type): Correct and implement.
	(type_suffixes, type_suffix_list, type_suffix): Implement actions.

	* cs-tokenizer.cs (real_type_suffix): Comment out the extra getchar.

	* cs-parser.jay (rank_specifiers): Remove space while concatenating the type's
	name and the specifiers.

	* interface.cs (InterfaceAttr): New property to return the corresponding TypeAttributes
	
	* rootcontext.cs (CreateInterface): Use the InterfaceAttr property instead of 
	making them all public ;-)

	* cs-parser.jay (error): Remove entirely as we have an implementation in the base
	class anyways.
	
2001-09-07  Miguel de Icaza  <miguel@ximian.com>

	* expression.cs (ExprClassFromMemberInfo): Return FieldExpr and
	PropertyExprs.
	(FieldExpr, PropertyExprs): New resolved expressions.
	(SimpleName::MemberStaticCheck): Perform static checks for access
	to non-static fields on static methods. Maybe this should be
	generalized for MemberAccesses. 
	(SimpleName::ResolveSimpleName): More work on simple name
	resolution. 

	* cs-parser.jay (primary_expression/qualified_identifier): track
	the parameter index.

	* codegen.cs (CodeGen::Save): Catch save exception, report error.
	(EmitContext::EmitBoolExpression): Chain to expression generation
	instead of temporary hack.
	(::EmitStatementExpression): Put generic expression code generation.

	* assign.cs (Assign::Emit): Implement variable assignments to
	local variables, parameters and fields.

2001-09-06  Miguel de Icaza  <miguel@ximian.com>

	* statement.cs (Block::GetVariableInfo): New method, returns the
	VariableInfo for a variable name in a block.
	(Block::GetVariableType): Implement in terms of GetVariableInfo

	* literal.cs (IntLiteral::Emit, FloatLiteral::Emit,
	DoubleLiteral::Emit, CharLiteral::Emit, BoolLiteral::Emit): Implement

2001-09-06  Ravi Pratap  <ravi@ximian.com>

	* cs-parser.jay (operator_declaration): Continue on my quest : update
	to take attributes argument.
	(event_declaration): Ditto.
	(enum_declaration): Ditto.
	(indexer_declaration): Ditto.
	
	* class.cs (Operator::Operator): Update constructor accordingly.
	(Event::Event): Ditto.

	* delegate.cs (Delegate::Delegate): Same here.

	* enum.cs (Enum::Enum): Same here.
	
2001-09-05  Ravi Pratap  <ravi@ximian.com>

	* cs-parser.jay (CheckAttributeTarget): Update to use the right error number.

	* ../tests/cs0658.cs : New file to demonstrate error 0658.

	* attribute.cs (Attributes): New class to encapsulate all attributes which were
	being passed around as an arraylist.
	(Attributes::AddAttribute): Method to add attribute sections.

	* cs-parser.jay (opt_attributes): Modify actions to use the new Attributes class.
	(struct_declaration): Update accordingly.
	(constant_declaration): Update.
	(field_declaration): Update.
	(method_header): Update.
	(fixed_parameter): Update.
	(parameter_array): Ditto.
	(property_declaration): Ditto.
	(destructor_declaration): Ditto.
	
	* class.cs (Struct::Struct): Update constructors accordingly.
	(Class::Class): Ditto.
	(Field::Field): Ditto.
	(Method::Method): Ditto.
	(Property::Property): Ditto.
	(TypeContainer::OptAttribute): update property's return type.
	
	* interface.cs (Interface.opt_attributes): New member.
	(Interface::Interface): Update to take the extra Attributes argument.

	* parameter.cs (Parameter::Parameter): Ditto.

	* constant.cs (Constant::Constant): Ditto.

	* interface.cs (InterfaceMemberBase): New OptAttributes field.
	(InterfaceMemberBase::InterfaceMemberBase): Update constructor to take 
	the attributes as a parameter.
	(InterfaceProperty): Update constructor call.
	(InterfaceEvent): Ditto.
	(InterfaceMethod): Ditto.
	(InterfaceIndexer): Ditto.

	* cs-parser.jay (interface_indexer_declaration): Update call to constructor to 
	pass the attributes too.
	(interface_event_declaration): Ditto.
	(interface_property_declaration): Ditto.
	(interface_method_declaration): Ditto.
	(interface_declaration): Ditto.

2001-09-05  Miguel de Icaza  <miguel@ximian.com>

	* class.cs (Method::Define): Track the "static Main" definition to
	create an entry point. 

	* rootcontext.cs (RootContext::EntryPoint): MethodInfo that holds the
	EntryPoint if we find it. 

	* codegen.cs (EmitContext::EmitInvocation): Emit invocations.
	(EmitContext::ig): Make this variable public.

	* driver.cs: Make the default output file be the first file name
	with the .exe extension.  

	Detect empty compilations

	Handle various kinds of output targets.  Handle --target and
	rename -t to --dumper.

	* expression.cs, literal.cs, assign.cs, constant.cs: All `Resolve'
	methods inherited from Expression return now an Expression.  This
	will is used during the tree rewriting as we resolve them during
	semantic analysis.

	(Expression::MemberLookup): Implements the MemberLookup (7.3) from
	the spec.  Missing entirely is the information about
	accessability of elements of it.

	(Expression::ExprClassFromMemberInfo): New constructor for
	Expressions that creates a fully initialized Expression based on
	a MemberInfo that is one of Eventinfo, FieldINfo, PropertyInfo or
	a Type.

	(Invocation::Resolve): Begin implementing resolution of invocations.
	
	* literal.cs (StringLiteral):  Implement Emit.

2001-09-05  Ravi Pratap  <ravi@ximian.com>

	* cs-parser.jay (error): Add new modifier because we are hiding an inherited
	member.
	
2001-09-04  Ravi Pratap  <ravi@ximian.com>

	* cs-parser.jay (attribute_arguments): Implement actions.
	(attribute): Fix bug in production. Implement action.
	(attribute_list): Implement.
	(attribute_target): Implement.
	(attribute_target_specifier, opt_target_specifier): Implement
	(CheckAttributeTarget): New method to check if the attribute target
	is valid.
	(attribute_section): Implement.
	(opt_attributes): Implement.

	* attribute.cs : New file to handle attributes.
	(Attribute): Class to hold attribute info.

	* cs-parser.jay (opt_attribute_target_specifier): Remove production
	(attribute_section): Modify production to use 2 different rules to 
	achieve the same thing. 1 s/r conflict down !
	Clean out commented, useless, non-reducing dimension_separator rules.
	
	* class.cs (TypeContainer.attributes): New member to hold list
	of attributes for a type.
	(Struct::Struct): Modify to take one more argument, the attribute list.
	(Class::Class): Ditto.
	(Field::Field): Ditto.
	(Method::Method): Ditto.
	(Property::Property): Ditto.
	
	* cs-parser.jay (struct_declaration): Update constructor call to
	pass in the attributes too.
	(class_declaration): Ditto.
	(constant_declaration): Ditto.
	(field_declaration): Ditto.
	(method_header): Ditto.
	(fixed_parameter): Ditto.
	(parameter_array): Ditto.
	(property_declaration): Ditto.

	* constant.cs (Constant::Constant): Update constructor similarly.
	Use System.Collections.

	* parameter.cs (Parameter::Parameter): Update as above.

2001-09-02  Ravi Pratap  <ravi@ximian.com>

	* class.cs (TypeContainer::AddDelegate): New method to add a delegate.
	(TypeContainer.delegates): New member to hold list of delegates.

	* cs-parser.jay (delegate_declaration): Implement the action correctly 
	this time as I seem to be on crack ;-)

2001-09-02  Miguel de Icaza  <miguel@ximian.com>

	* rootcontext.cs (RootContext::IsNamespace): new function, used to
	tell whether an identifier represents a namespace.

	* expression.cs (NamespaceExpr): A namespace expression, used only
	temporarly during expression resolution.
	(Expression::ResolveSimpleName, ::ResolvePrimary, ::ResolveName):
	utility functions to resolve names on expressions.

2001-09-01  Miguel de Icaza  <miguel@ximian.com>

	* codegen.cs: Add hook for StatementExpressions. 

	* class.cs: Fix inverted test for static flag in methods.

2001-09-02  Ravi Pratap  <ravi@ximian.com>

	* class.cs (Operator::CheckUnaryOperator): Correct error number used
	to make it coincide with MS' number.
	(Operator::CheckBinaryOperator): Ditto.

	* ../errors/errors.txt : Remove error numbers added earlier.

	* ../errors/cs1019.cs : Test case for error # 1019

	* ../errros/cs1020.cs : Test case for error # 1020

	* cs-parser.jay : Clean out commented cruft.
	(dimension_separators, dimension_separator): Comment out. Ostensibly not
	used anywhere - non-reducing rule.
	(namespace_declarations): Non-reducing rule - comment out.

	* enum.cs (Enum::AddEnum): Rename to AddEnumMember as I was getting confused
	with TypeContainer::AddEnum.

	* delegate.cs : New file for delegate handling classes.
	(Delegate): Class for declaring delegates.

	* makefile : Update.

	* cs-parser.jay (delegate_declaration): Implement.

2001-09-01  Ravi Pratap  <ravi@che.iitm.ac.in>

	* class.cs (Event::Define): Implement.
	(Event.EventBuilder): New member.

	* class.cs (TypeContainer::Populate): Update to define all enums and events
	we have.
	(Events): New property for the events arraylist we hold. Shouldn't we move to using
	readonly fields for all these cases ?

2001-08-31  Ravi Pratap  <ravi@che.iitm.ac.in>

	* class.cs (Property): Revamp to use the convention of making fields readonly.
	Accordingly modify code elsewhere.

	* class.cs : Apply patch from Mr. Mandar <go_mono@hotmail.com> for implementing
	the Define method of the Property class.

	* class.cs : Clean up applied patch and update references to variables etc. Fix 
	trivial bug.
	(TypeContainer::Populate): Update to define all the properties we have. Also
	define all enumerations.

	* enum.cs (Define): Implement.
	
2001-08-31  Ravi Pratap  <ravi@che.iitm.ac.in>

	* cs-parser.jay (overloadable_operator): The semantic value is an
	enum of the Operator class.
	(operator_declarator): Implement actions.
	(operator_declaration): Implement.

	* class.cs (Operator::CheckUnaryOperator): New static method to help in checking
	validity of definitions.
	(Operator::CheckBinaryOperator): Static method to check for binary operators
	(TypeContainer::AddOperator): New method to add an operator to a type.

	* cs-parser.jay (indexer_declaration): Added line to actually call the
	AddIndexer method so it gets added ;-)

	* ../errors/errors.txt : Update to include new error numbers. Are these numbers 
	already taken care of by the MS compiler ?  

2001-08-29  Ravi Pratap  <ravi@che.iitm.ac.in>

	* class.cs (Operator): New class for operator declarations.
	(Operator::OpType): Enum for the various operators.

2001-08-29  Ravi Pratap  <ravi@che.iitm.ac.in>

	* class.cs (TypeContainer::AddIndexer): Remove FIXME comment. We
	ostensibly handle this in semantic analysis.

	* cs-parser.jay (general_catch_clause): Comment out
	(specific_catch_clauses, specific_catch_clause): Ditto.
	(opt_general_catch_clause, opt_specific_catch_clauses): Ditto
	(catch_args, opt_catch_args): New productions.
	(catch_clause): Rewrite to use the new productions above
	(catch_clauses): Modify accordingly.
	(opt_catch_clauses): New production to use in try_statement
	(try_statement): Revamp. Basically, we get rid of one unnecessary rule
	and re-write the code in the actions to extract the specific and
	general catch clauses by being a little smart ;-)

	* ../tests/try.cs : Fix. It's not 'finalize' my friend, it's 'finally' !
	Hooray, try and catch statements parse fine !
	
2001-08-28  Ravi Pratap  <ravi@che.iitm.ac.in>

	* statement.cs (Block::GetVariableType): Fix logic to extract the type
	string from the hashtable of variables.

	* cs-parser.jay (event_accessor_declarations): Trivial fix. Man, how did
	I end up making that mistake ;-)
	(catch_clauses): Fixed gross error which made Key and Value of the 
	DictionaryEntry the same : $1 !!

2001-08-28  Ravi Pratap  <ravi@che.iitm.ac.in>

	* cs-tokenizer.cs (initTokens): Add keywords 'add' and 'remove'

	* cs-parser.jay (event_declaration): Correct to remove the semicolon
	when the add and remove accessors are specified. 

2001-08-28  Ravi Pratap  <ravi@che.iitm.ac.in>

	* cs-parser.jay (IndexerDeclaration): New helper class to hold
	information about indexer_declarator.
	(indexer_declarator): Implement actions.
	(parsing_indexer): New local boolean used to keep track of whether
	we are parsing indexers or properties. This is necessary because 
	implicit_parameters come into picture even for the get accessor in the 
	case of an indexer.
	(get_accessor_declaration, set_accessor_declaration): Correspondingly modified.

	* class.cs (Indexer): New class for indexer declarations.
	(TypeContainer::AddIndexer): New method to add an indexer to a type.
	(TypeContainer::indexers): New member to hold list of indexers for the
	type.

2001-08-27  Ravi Pratap  <ravi@che.iitm.ac.in>

	* cs-parser.jay (add_accessor_declaration): Implement action.
	(remove_accessor_declaration): Implement action.
	(event_accessors_declaration): Implement
	(variable_declarators): swap statements for first rule - trivial.

	* class.cs (Event): New class to hold information about event
	declarations.
	(TypeContainer::AddEvent): New method to add an event to a type
	(TypeContainer::events): New member to hold list of events.

	* cs-parser.jay (event_declaration): Implement actions.

2001-08-27  Ravi Pratap  <ravi@che.iitm.ac.in>

	* cs-parser.jay (dim_separators): Implement. Make it a string
	concatenating all the commas together, just as they appear.
	(opt_dim_separators): Modify accordingly
	(rank_specifiers): Update accordingly. Basically do the same
	thing - instead, collect the brackets here.
	(opt_rank_sepcifiers): Modify accordingly.
	(array_type): Modify to actually return the complete type string
	instead of ignoring the rank_specifiers.
	(expression_list): Implement to collect the expressions
	(variable_initializer): Implement. We make it a list of expressions
	essentially so that we can handle the array_initializer case neatly too.
	(variable_initializer_list): Implement.
	(array_initializer): Make it a list of variable_initializers
	(opt_array_initializer): Modify accordingly.

	* expression.cs (New::NType): Add enumeration to help us
	keep track of whether we have an object/delegate creation
	or an array creation.
	(New:NewType, New::Rank, New::Indices, New::Initializers): New
	members to hold data about array creation.
	(New:New): Modify to update NewType
	(New:New): New Overloaded contructor for the array creation
	case.

	* cs-parser.jay (array_creation_expression): Implement to call
	the overloaded New constructor.
	
2001-08-26  Ravi Pratap  <ravi@che.iitm.ac.in>

	* class.cs (TypeContainer::Constructors): Return member
	constructors instead of returning null.

2001-08-26  Miguel de Icaza  <miguel@ximian.com>

	* typemanager.cs (InitCoreTypes): Initialize the various core
	types after we have populated the type manager with the user
	defined types (this distinction will be important later while
	compiling corlib.dll)

	* expression.cs, literal.cs, assign.cs, constant.cs: Started work
	on Expression Classification.  Now all expressions have a method
	`Resolve' and a method `Emit'.

	* codegen.cs, cs-parser.jay: Fixed the bug that stopped code
	generation from working.     Also add some temporary debugging
	code. 
	
2001-08-24  Miguel de Icaza  <miguel@ximian.com>

	* codegen.cs: Lots of code generation pieces.  This is only the
	beginning, will continue tomorrow with more touches of polish.  We
	handle the fundamentals of if, while, do, for, return.  Others are
	trickier and I need to start working on invocations soon.
	
	* gen-treedump.cs: Bug fix, use s.Increment here instead of
	s.InitStatement. 

	* codegen.cs (EmitContext): New struct, used during code
	emission to keep a context.   Most of the code generation will be
	here. 

	* cs-parser.jay: Add embedded blocks to the list of statements of
	this block.  So code generation proceeds in a top down fashion.

2001-08-23  Miguel de Icaza  <miguel@ximian.com>

	* statement.cs: Add support for multiple child blocks.

2001-08-22  Miguel de Icaza  <miguel@ximian.com>

	* codegen.cs (EmitCode): New function, will emit the code for a
	Block of code given a TypeContainer and its ILGenerator. 

	* statement.cs (Block): Standard public readonly optimization.
	(Block::Block constructors): Link children. 
	(Block::Child): Child Linker.
	(Block::EmitVariables): Emits IL variable declarations.

	* class.cs: Drop support for MethodGroups here, delay until
	Semantic Analysis.
	(Method::): Applied the same simplification that I did before, and
	move from Properties to public readonly fields.
	(Method::ParameterTypes): Returns the parameter types for the
	function, and implements a cache that will be useful later when I
	do error checking and the semantic analysis on the methods is
	performed.
	(Constructor::GetCallingConvention): Renamed from CallingConvetion
	and made a method, optional argument tells whether this is a class
	or a structure to apply the `has-this' bit.
	(Method::GetCallingConvention): Implement, returns the calling
	convention. 
	(Method::Define): Defines the type, a second pass is performed
	later to populate the methods.

	(Constructor::ParameterTypes): implement a cache similar to the
	one on Method::ParameterTypes, useful later when we do semantic
	analysis. 

	(TypeContainer::EmitMethod):  New method.  Emits methods.

	* expression.cs: Removed MethodGroup class from here.
	
	* parameter.cs (Parameters::GetCallingConvention): new method.

2001-08-21  Miguel de Icaza  <miguel@ximian.com>

	* class.cs (TypeContainer::Populate): Drop RootContext from the
	argument. 

	(Constructor::CallingConvention): Returns the calling convention.
	(Constructor::ParameterTypes): Returns the constructor parameter
	types. 
	
	(TypeContainer::AddConstructor): Keep track of default constructor
	and the default static constructor.

	(Constructor::) Another class that starts using `public readonly'
	instead of properties. 

	(Constructor::IsDefault): Whether this is a default constructor. 

	(Field::) use readonly public fields instead of properties also.

	(TypeContainer::TypeAttr, TypeContainer::AddConstructor): Keep
	track of static constructors;  If none is used, turn on
	BeforeFieldInit in the TypeAttributes. 

	* cs-parser.jay (opt_argument_list): now the return can be null
	for the cases where there are no arguments. 

	(constructor_declarator): If there is no implicit `base' or
	`this', then invoke the default parent constructor. 
	
	* modifiers.cs (MethodAttr): New static function maps a set of
	modifiers flags into a MethodAttributes enum
	(FieldAttr): renamed from `Map'.  So now we have FieldAttr,
	MethodAttr, TypeAttr to represent the various mappings where the
	modifiers are used.
	(FieldAttr): Map also `readonly' to `FieldAttributes.InitOnly' 	

2001-08-19  Miguel de Icaza  <miguel@ximian.com>

	* parameter.cs (GetParameterInfo): Fix bug where there would be no
	method arguments.

	* interface.cs (PopulateIndexer): Implemented the code generator
	for interface indexers.

2001-08-17  Miguel de Icaza  <miguel@ximian.com>

	* interface.cs (InterfaceMemberBase): Now we track the new status
	here.  

	(PopulateProperty): Implement property population.  Woohoo!  Got
	Methods and Properties going today. 

	Removed all the properties for interfaces, and replaced them with
	`public readonly' fields. 

2001-08-16  Miguel de Icaza  <miguel@ximian.com>

	* interface.cs (AddEvent, AddMethod, AddIndexer, AddProperty):
	initialize their hashtables/arraylists only when they are needed
	instead of doing this always.

	* parameter.cs: Handle refs and out parameters.

	* cs-parser.jay: Use an ArrayList to construct the arguments
	instead of the ParameterCollection, and then cast that to a
	Parameter[] array.

	* parameter.cs: Drop the use of ParameterCollection and use
	instead arrays of Parameters.

	(GetParameterInfo): Use the Type, not the Name when resolving
	types. 

2001-08-13  Miguel de Icaza  <miguel@ximian.com>

	* parameter.cs: Eliminate the properties Name, Type and ModFlags,
	and instead use public readonly fields.

	* class.cs: Put back walking code for type containers.

2001-08-11  Miguel de Icaza  <miguel@ximian.com>

	* class.cs (MakeConstant): Code to define constants.

	* rootcontext.cs (LookupType): New function.  Used to locate types 

	
2001-08-08  Miguel de Icaza  <miguel@ximian.com>

	* rootcontext.cs: OH MY!  My trick works!   It is amazing how nice
	this System.Reflection code is.  Kudos to Microsoft
	
	* typemanager.cs: Implement a type cache and avoid loading all
	types at boot time.  Wrap in LookupType the internals.  This made
	the compiler so much faster.  Wow.  I rule!
	
	* driver.cs: Make sure we always load mscorlib first (for
	debugging purposes, nothing really important).

	* Renamespaced things that were on `CSC' to `CIR'.  Maybe I should
	have moved to `CSC' rather than `CIR'.  Oh man!  The confussion!  

	* rootcontext.cs: Lookup types on their namespace;  Lookup types
	on namespaces that have been imported using the `using' keyword.

	* class.cs (TypeContainer::TypeAttr): Virtualize.
	(Class::TypeAttr): Return attributes suitable for this bad boy.
	(Struct::TypeAttr): ditto.
	Handle nested classes.
	(TypeContainer::) Remove all the type visiting code, it is now
	replaced with the rootcontext.cs code

	* rootcontext.cs (GetClassBases): Added support for structs. 

2001-08-06  Miguel de Icaza  <miguel@ximian.com>

	* interface.cs, statement.cs, class.cs, parameter.cs,
	rootcontext.cs, gen-treedump.cs, enum.cs, cs-parse.jay:
	Drop use of TypeRefs, and use strings instead.

2001-08-04  Miguel de Icaza  <miguel@ximian.com>

	* rootcontext.cs: 

	* class.cs (Struct::Struct): set the SEALED flags after
	checking the modifiers.
	(TypeContainer::TypeAttr): new property, returns the
	TypeAttributes for a class.  

	* cs-parser.jay (type_list): Oops, list production was creating a
	new list of base types.

	* rootcontext.cs (StdLib): New property.
	(GetInterfaceTypeByName): returns an interface by type name, and
	encapsulates error handling here.
	(GetInterfaces): simplified.
	(ResolveTree): Encapsulated all the tree resolution here.
	(CreateClass, GetClassBases, GetInterfaceOrClass): Create class
	types. 
	
	* driver.cs: Add support for --nostdlib, to avoid loading the
	default assemblies.
	(Main): Do not put tree resolution here. 

	* rootcontext.cs: Beginning of the class resolution.

2001-08-03  Miguel de Icaza  <miguel@ximian.com>

	* rootcontext.cs: Provide better error reporting. 

	* cs-parser.jay (interface_base): set our $$ to be interfaces.

	* rootcontext.cs (CreateInterface): Handle the case where there
	are no parent interfaces.
	
	(CloseTypes): Routine to flush types at the end.
	(CreateInterface): Track types.
	(GetInterfaces): Returns an array of Types from the list of
	defined interfaces.

	* typemanager.c (AddUserType): Mechanism to track user types (puts
	the type on the global type hash, and allows us to close it at the
	end). 
	
2001-08-02  Miguel de Icaza  <miguel@ximian.com>

	* tree.cs: Removed RecordType, added RecordClass, RecordStruct and
	RecordInterface instead.

	* cs-parser.jay: Updated to reflect changes above.

	* decl.cs (Definition): Keep track of the TypeBuilder type that
	represents this type here.  Not sure we will use it in the long
	run, but wont hurt for now.

	* driver.cs: Smaller changes to accomodate the new code.

	Call ResolveInterfaceBases, Call ResolveClassBases, Save assembly
	when done. 

	* rootcontext.cs (CreateInterface):  New method, used to create
	the System.TypeBuilder type for interfaces.
	(ResolveInterfaces): new entry point to resolve the interface
	hierarchy. 
	(CodeGen): Property, used to keep track of the code generator.

2001-07-26  Miguel de Icaza  <miguel@ximian.com>

	* cs-parser.jay: Add a second production for delegate_declaration
	with `VOID'.

	(enum_body): Put an opt_comma here instead of putting it on
	enum_body or enum_member_declarations so we can handle trailing
	commas on enumeration members.  Gets rid of a shift/reduce.
	
	(type_list): Need a COMMA in the middle.

	(indexer_declaration): Tell tokenizer to recognize get/set

	* Remove old targets.

	* Re-add the parser target.

2001-07-13  Simon Cozens <simon@simon-cozens.org>

	* cs-parser.jay: Add precendence rules for a number of operators
	ot reduce the number of shift/reduce conflicts in the grammar.
	
2001-07-17  Miguel de Icaza  <miguel@ximian.com>

	* tree.cs: moved IGenerator interface and renamed it to ITreeDump
	and put it here.

	Get rid of old crufty code.

	* rootcontext.cs: Use this to keep track of the parsed
	representation and the defined types available to the program. 

	* gen-treedump.cs: adjust for new convention.

	* type.cs: Split out the type manager, and the assembly builder
	from here. 

	* typemanager.cs: the type manager will live here now.

	* cil-codegen.cs: And the code generator here. 

2001-07-14  Sean MacIsaac  <macisaac@ximian.com>

	* makefile: Fixed up for easy making.

2001-07-13  Simon Cozens <simon@simon-cozens.org>

	* cs-parser.jay (rank_specifier): Remove a conflict by reordering
	the 

	(unary_expression): Expand pre_increment_expression and
	post_decrement_expression to reduce a shift/reduce.

2001-07-11  Simon Cozens

	* cs-tokenizer.cs: Hex numbers should begin with a 0.

	Improve allow_keyword_as_indent name.

2001-06-19  Miguel de Icaza  <miguel@ximian.com>

	* Adjustments for Beta2. 

2001-06-13  Miguel de Icaza  <miguel@ximian.com>

	* decl.cs: Added `Define' abstract method.
	(InTransit): new property, used to catch recursive definitions. 

	* interface.cs: Implement `Define'. 

	* modifiers.cs: Map Modifiers.constants to
	System.Reflection.TypeAttribute flags.

	* class.cs: Keep track of types and user-defined types.
	(BuilderInit): New method for creating an assembly
	(ResolveType): New function to launch the resolution process, only
	used by interfaces for now.

	* cs-parser.jay: Keep track of Classes, Structs and Interfaces
	that are inserted into the name space. 

2001-06-08  Miguel de Icaza  <miguel@ximian.com>

	* ARGH.  I have screwed up my tree so many times due to the use of
	rsync rather than using CVS.  Going to fix this at once. 

	* driver.cs: Objetify driver.  Load assemblies, use assemblies to
	load types.

2001-06-07  Miguel de Icaza  <miguel@ximian.com>

	* Experiment successful: Use System.Type rather that our own
	version of Type.  

2001-05-25  Miguel de Icaza  <miguel@ximian.com>

	* cs-parser.jay: Removed nsAliases from here.

	Use new namespaces, handle `using XXX;' 

	* namespace.cs: Reimplemented namespace handling, use a recursive
	definition of the class.  Now we can keep track of using clauses
	and catch invalid using clauses.

2001-05-24  Miguel de Icaza  <miguel@ximian.com>

	* gen-treedump.cs: Adapted for all the renaming.

	* expression.cs (Expression): this class now has a Type property
	which returns an expression Type.

	(Probe::, New::, TypeOf::, SizeOf::, Constant::): renamed from
	`Type', as this has a different meaning now in the base

2001-05-22  Miguel de Icaza  <miguel@ximian.com>

	* interface.cs, class.cs: Removed from all the sources the
	references to signature computation, as we can not do method
	signature computation during the parsing time, as we are not
	trying to solve at that point distinguishing:

	class X {
		void a (Blah x) {}
		void a (NS.Blah x) {}
	}

	Which depending on the context might be valid or not, as we do not
	know if Blah is the same thing as NS.Blah at that point.

	* Redid everything so the code uses TypeRefs now instead of
	Types.  TypeRefs are just temporary type placeholders, that need
	to be resolved.  They initially have a pointer to a string and the
	current scope in which they are used.  This is used later by the
	compiler to resolve the reference to an actual Type. 

	* DeclSpace is no longer a CIR.Type, and neither are
	TypeContainers (Class and Struct) nor Interfaces nor Enums.  They
	are all DeclSpaces, but no Types. 

	* type.cs (TypeRefManager): This implements the TypeRef manager,
	which keeps track of all the types that need to be resolved after
	the parsing has finished. 

2001-05-13  Miguel de Icaza  <miguel@ximian.com>

	* ARGH.  We are going to have to store `foreach' as a class rather
	than resolving it, as we need to verify error 1579 after name
	resolution.   *OR* we could keep a flag that says `This request to
	IEnumerator comes from a foreach statement' which we can then use
	to generate the error.

2001-05-10  Miguel de Icaza  <miguel@ximian.com>

	* class.cs (TypeContainer.AddMethod): we now add methods to the
	MethodGroup instead of the method hashtable.  

	* expression.cs: Add MethodGroup abstraction, which gets us one
	step closer to the specification in the way we handle method
	declarations.  

	* cs-parser.jay (primary_expression): qualified_identifier now
	tried to match up an identifier to a local variable reference or
	to a parameter reference.

	current_local_parameters is now a parser global variable that
	points to the current parameters for the block, used during name
	lookup.

	(property_declaration): Now creates an implicit `value' argument to
	the set accessor.

2001-05-09  Miguel de Icaza  <miguel@ximian.com>

	* parameter.cs: Do not use `param' arguments as part of the
	signature, per the spec.

2001-05-08  Miguel de Icaza  <miguel@ximian.com>

	* decl.cs: Base class for classes, structs and interfaces.  This
	is the "Declaration Space" 

	* cs-parser.jay: Use CheckDef for checking declaration errors
	instead of having one on each function.

	* class.cs: Factor out some code for handling error handling in
	accordance to the "Declarations" section in the "Basic Concepts"
	chapter in the ECMA C# spec.

	* interface.cs: Make all interface member classes derive from
	InterfaceMemberBase.

2001-05-07  Miguel de Icaza  <miguel@ximian.com>

	* Many things: all interfaces are parsed and generated in
	gen-treedump.  Support for member variables, constructors,
	destructors, properties, constants is there.

	Beginning of the IL backend, but very little done, just there for
	testing purposes. 

2001-04-29  Miguel de Icaza  <miguel@ximian.com>

	* cs-parser.jay: Fix labeled statement.

	* cs-tokenizer.cs (escape): Escape " and ' always.
	ref_line, ref_name: keep track of the line/filename as instructed
	by #line by the compiler.
	Parse #line.

2001-04-27  Miguel de Icaza  <miguel@ximian.com>

	* System.CodeDOM/CodeBinaryOperatorExpression.cs: Rearrange enum
	to match the values in System.CodeDOM.

	Divid renamed to Divide.

	* System.CodeDOM/CodeForLoopStatement.cs: Always have valid
	statements. 
	(Statements.set): remove.

	* System.CodeDOM/CodeCatchClause.cs: always have a valid
	statements. 

	* System.CodeDOM/CodeIfStatement.cs: trueStatements and
	falseStatements always have valid values. 

	* cs-parser.jay: Use System.CodeDOM now.