+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.
projects / mono.git / blobdiff