+2001-10-02 Miguel de Icaza <miguel@ximian.com>
+
+ * 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):