//
// Authors: Miguel de Icaza (miguel@gnu.org)
// Martin Baulig (martin@gnome.org)
+// Anirban Bhattacharjee (banirban@novell.com)
//
// Licensed under the terms of the GNU GPL
//
// Holds the operators
ArrayList operators;
+ // Holds AddHandlers stements for events
+ ArrayList handlers;
+
// The emit context for toplevel objects.
EmitContext ec;
default_static_constructor = c;
} else {
if (c.IsDefault ()){
- if (default_constructor != null)
- return AdditionResult.MethodExists;
+ /*if (default_constructor != null)
+ return AdditionResult.MethodExists;*/
default_constructor = c;
}
return AdditionResult.Success;
}
+ public AdditionResult AddEventHandler (Statement stmt)
+ {
+ if (handlers == null)
+ handlers = new ArrayList ();
+
+ handlers.Add (stmt);
+ return AdditionResult.Success;
+ }
+
public void RegisterOrder (Interface iface)
{
if (interface_order == null)
}
}
+ public ArrayList EventHandlers {
+ get {
+ return handlers;
+ }
+ }
+
//
// Emits the instance field initializers
//
int mods = 0;
c = new Constructor ("New", Parameters.EmptyReadOnlyParameters,
- new ConstructorBaseInitializer (
- null, Parameters.EmptyReadOnlyParameters,
- Location.Null),
+ null,
Location.Null);
- if (is_static)
+ if (is_static) {
mods = Modifiers.STATIC;
-
- c.ModFlags = mods;
+ c.ModFlags = mods;
+ }
+ else
+ c.Initializer = new ConstructorBaseInitializer (
+ null, Parameters.EmptyReadOnlyParameters,
+ Location.Null);
AddConstructor (c);
foreach (Field f in initialized_fields){
Report.Error (
- 573, Location,
+ 31049, Location,
"`" + n + "." + f.Name + "': can not have " +
"instance field initializers in structs");
}
start = 0;
}
+ if (parent.IsSealed )
+ Report.Error (30299, Location,
+ "Class " + Name + " cannot inherit " +
+ "'NotInheritable' class " + TypeManager.MonoBASIC_Name (parent));
+
if (!AsAccessible (parent, ModFlags))
- Report.Error (60, Location,
+ Report.Error (30389, Location,
"Inconsistent accessibility: base class `" +
TypeManager.MonoBASIC_Name (parent) + "' is less " +
"accessible than class `" +
Expression resolved = ResolveTypeExpr (name, false, Location);
bases [i] = resolved;
Type t = resolved.Type;
-
+
if (t == null){
error = true;
return null;
error = true;
return null;
}
-
+
if (t.IsSealed) {
- string detail = "";
-
- if (t.IsValueType)
- detail = " (a class can not inherit from a struct/enum)";
+ if (t.IsValueType)\r
+ Report.Error (30258, "class `"+ Name +
+ "': a class can not inherit from a struct/enum");
- Report.Error (509, "class `"+ Name +
+ /*Report.Error (509, "class `"+ Name +
"': Cannot inherit from sealed class `"+
- bases [i]+"'"+detail);
+ bases [i]);*/
error = true;
return null;
}
if (t.IsClass) {
if (parent != null){
- Report.Error (527, "In Class `" + Name + "', type `"+
- name+"' is not an interface");
+ Report.Error (30121, Name + ": A class cannot inherit " +
+ "more than one class");
error = true;
return null;
}
ec = new EmitContext (this, Mono.MonoBASIC.Location.Null, null, null, ModFlags);
+ if (((ModFlags & Modifiers.ABSTRACT ) != 0) &&
+ ((ModFlags & Modifiers.SEALED) != 0)){
+ Report.Error (31408, Location,
+ "Class declared as 'MustInherit' cannot be declared as 'NotInheritable'");
+ }
+
ifaces = GetClassBases (is_class, out parent, out error);
if (error)
return null;
+ if (this is Interface)
+ parent = null;
+
if (is_class && parent != null){
if (parent == TypeManager.enum_type ||
(parent == TypeManager.value_type && RootContext.StdLib) ||
if (!is_class && TypeManager.value_type == null)
throw new Exception ();
+ if (is_class && Parent.Parent == null && (!(this is Interface))) \r
+ {
+ if ((ModFlags & Modifiers.PRIVATE) != 0)
+ Report.Error (31089, Location,
+ "Only internal classes can be declared as 'Private'");
+
+ if ((ModFlags & Modifiers.PROTECTED) != 0)
+ Report.Error (31047, Location,
+ "Only internal classes can be declared as 'Protected'");
+ }
+
+ if ((Parent is Module) && ((ModFlags & Modifiers.PROTECTED) != 0))
+ Report.Error (30735, Location,
+ "'Type' inside a 'Module' can not be " +
+ "declared as 'Protected'");
+
+ if ((Parent is Struct) && ((ModFlags & Modifiers.PROTECTED) != 0))
+ Report.Error (30435, Location,
+ "'Type' inside a 'Structure' can not be " +
+ "declared as 'Protected'");
+
TypeAttributes type_attributes = TypeAttr;
// if (parent_builder is ModuleBuilder) {
Basename, type_attributes, parent, ifaces);
}
- //
- // Structs with no fields need to have at least one byte.
- // The right thing would be to set the PackingSize in a DefineType
- // but there are no functions that allow interfaces *and* the size to
- // be specified.
- //
+ if (!is_class)
+ {
+ // structure must contain atleast one member variable
+ if(!have_nonstatic_fields){
+ Report.Error (
+ 30281, Location, "Structure `" + Name + "' do not " +
+ "contain any member Variable");
- if (!is_class && !have_nonstatic_fields){
- TypeBuilder.DefineField ("$PRIVATE$", TypeManager.byte_type,
- FieldAttributes.Private);
- }
+ /*TypeBuilder.DefineField ("$PRIVATE$", TypeManager.byte_type,
+ FieldAttributes.Private);*/
+ }
- // add interfaces that were not added at type creation (weird API issue)
- if (!is_class && !have_nonstatic_fields && (ifaces != null)) {
- foreach (Type i in ifaces)
- TypeBuilder.AddInterfaceImplementation (i);
+ // add interfaces that were not added at type creation (weird API issue)
+ if (!have_nonstatic_fields && (ifaces != null)) {
+ foreach (Type i in ifaces)
+ TypeBuilder.AddInterfaceImplementation (i);
+ }
}
+
//
// Finish the setup for the EmitContext
if (fields != null)
DefineMembers (fields, defined_names);
- if (this is Class){
+ if (this is Class && (!(this is Interface))){
if (instance_constructors == null){
if (default_constructor == null) \r
DefineDefaultConstructor (false);
continue;
MemberInfo pb = p.PropertyBuilder;
+
if (pb != null && filter (pb, criteria) == true) {
members.Add (p.PropertyBuilder);
}
foreach (Indexer ix in indexers)
ix.Emit (this);
- CustomAttributeBuilder cb = Interface.EmitDefaultMemberAttr (
+ /*CustomAttributeBuilder cb = Interface.EmitDefaultMemberAttr (
this, IndexerName, ModFlags, Location);
- TypeBuilder.SetCustomAttribute (cb);
+ TypeBuilder.SetCustomAttribute (cb);*/
}
if (fields != null)
{
const int vao = (Modifiers.VIRTUAL | Modifiers.ABSTRACT | Modifiers.OVERRIDE);
const int va = (Modifiers.VIRTUAL | Modifiers.ABSTRACT);
- const int nv = (Modifiers.NEW | Modifiers.VIRTUAL);
+ const int nv = (Modifiers.SHADOWS | Modifiers.VIRTUAL);
bool ok = true;
string name = MakeName (n);
if ((flags & Modifiers.STATIC) != 0){
if ((flags & vao) != 0){
Report.Error (
- 112, loc, "static method " + name + "can not be marked " +
- "as virtual, abstract or override");
+ 30501, loc, "Shared method " + name + " can not be " +
+ "declared as Overridable");
ok = false;
}
}
}
}
- if ((flags & Modifiers.OVERRIDE) != 0 && (flags & nv) != 0){
+ if ((flags & Modifiers.OVERRIDE) != 0 && (flags & Modifiers.VIRTUAL) != 0)\r
+ {
Report.Error (
- 113, loc, name +
- " marked as override cannot be marked as new or virtual");
+ 30730, loc, name +
+ ": Methods marked as Overrides cannot be made Overridable");
+ ok = false;
+ }
+
+ if ((flags & Modifiers.OVERRIDE) != 0 && (flags & Modifiers.SHADOWS) != 0){
+ Report.Error (
+ 31408, loc, name +
+ ": Methods marked as Overrides cannot be marked as Shadows");
ok = false;
}
ok = false;
}
- if ((ModFlags & Modifiers.ABSTRACT) == 0){
+ if((ModFlags & Modifiers.SEALED) != 0){
+ Report.Error (
+ 30607, loc,
+ "Class declared as 'NotInheritable' " +
+ "cannot have a 'MustOverride' member");
+ ok = false;
+ }
+ else if ((ModFlags & Modifiers.ABSTRACT) == 0){
Report.Error (
- 513, loc, name +
- " is abstract but its container class is not");
+ 31411, loc, name +
+ " is declared as 'MustOverride', hence its container " +
+ "class should be declared as 'MustInherit'");
ok = false;
}
if ((flags & Modifiers.PRIVATE) != 0){
if ((flags & vao) != 0){
Report.Error (
- 621, loc, name +
- " virtual or abstract members can not be private");
+ 31408, loc, name +
+ ": Members marked as Overridable or Overrides can not be Private");
ok = false;
}
}
if ((flags & Modifiers.OVERRIDE) == 0){
Report.Error (
238, loc, name +
- " cannot be sealed because it is not an override");
+ ": cannot be sealed because it is not an override");
ok = false;
}
}
bool IMemberContainer.IsInterface {
get {
- return false;
+ return this is Interface;
}
}
if (parent.Parent == null)
accmods = Modifiers.INTERNAL;
else
- accmods = Modifiers.PRIVATE;
+ accmods = Modifiers.PUBLIC;
this.ModFlags = Modifiers.Check (AllowedModifiers, mod, accmods, l);
this.attributes = attrs;
if (parent.Parent == null)
accmods = Modifiers.INTERNAL;
else
- accmods = Modifiers.PRIVATE;
+ accmods = Modifiers.PUBLIC;
this.ModFlags = Modifiers.Check (AllowedModifiers, mod, accmods, l);
//
protected InternalParameters parameter_info;
protected Type [] parameter_types;
+
+ // Whether this is an operator
+ public bool IsOperator;
public MethodCore (Expression type, int mod, int allowed_mod, string name,
Attributes attrs, Parameters parameters, Location loc)
Modifiers.PRIVATE |
Modifiers.STATIC |
Modifiers.VIRTUAL |
- Modifiers.SEALED |
+ Modifiers.NONVIRTUAL |
Modifiers.OVERRIDE |
Modifiers.ABSTRACT |
Modifiers.UNSAFE |
return MemberType;
}
- // Whether this is an operator method.
- public bool IsOperator;
+ void DuplicateEntryPoint (MethodInfo b, Location location)
+ {
+ Report.Error (
+ 30738, location,
+ "Program `" + CodeGen.FileName +
+ "' has more than one entry point defined: `" +
+ TypeManager.MonoBASIC_Signature(b) + "'");
+ }
- void DuplicateEntryPoint (MethodInfo b, Location location)
- {
- Report.Error (
- 17, location,
- "Program `" + CodeGen.FileName +
- "' has more than one entry point defined: `" +
- TypeManager.MonoBASIC_Signature(b) + "'");
- }
-
- void Report28 (MethodInfo b)
- {
+ void Report28 (MethodInfo b)
+ {
if (RootContext.WarningLevel < 4)
return;
- Report.Warning (
- 28, Location,
- "`" + TypeManager.MonoBASIC_Signature(b) +
- "' has the wrong signature to be an entry point");
- }
-
- public bool IsEntryPoint (MethodBuilder b, InternalParameters pinfo)
- {
- if (b.ReturnType != TypeManager.void_type &&
- b.ReturnType != TypeManager.int32_type)
- return false;
-
- if (pinfo.Count == 0)
- return true;
-
- if (pinfo.Count > 1)
- return false;
-
- Type t = pinfo.ParameterType(0);
- if (t.IsArray &&
- (t.GetArrayRank() == 1) &&
- (t.GetElementType() == TypeManager.string_type) &&
- (pinfo.ParameterModifier(0) == Parameter.Modifier.NONE))
- return true;
- else
- return false;
- }
+ Report.Warning (
+ 28, Location,
+ "`" + TypeManager.MonoBASIC_Signature(b) +
+ "' has the wrong signature to be an entry point");
+ }
+
+ public bool IsEntryPoint (MethodBuilder b, InternalParameters pinfo)
+ {
+ if (b.ReturnType != TypeManager.void_type &&
+ b.ReturnType != TypeManager.int32_type)
+ return false;
+
+ if (pinfo.Count == 0)
+ return true;
+
+ if (pinfo.Count > 1)
+ return false;
+
+ Type t = pinfo.ParameterType(0);
+ if (t.IsArray &&
+ (t.GetArrayRank() == 1) &&
+ (t.GetElementType() == TypeManager.string_type) &&
+ (pinfo.ParameterModifier(0) == Parameter.Modifier.NONE))
+ return true;
+ else
+ return false;
+ }
//
// Checks our base implementation if any
WarningNotHiding (parent);*/
if ((ModFlags & Modifiers.OVERRIDE) != 0){
- Report.Error (115, Location,
+ Report.Error (30284, Location,
parent.MakeName (Name) +
- " no suitable methods found to override");
+ " : No suitable methods found to override");
}
+ if ((ModFlags & ( Modifiers.NEW | Modifiers.SHADOWS | Modifiers.OVERRIDE )) == 0) \r
+ {
+ if ((ModFlags & Modifiers.NONVIRTUAL) != 0)\r
+ {
+ Report.Error (31088, Location,
+ parent.MakeName (Name) + " : Cannot " +
+ "be declared NotOverridable since this method is " +
+ "not maked as Overrides");
+ }
+ }
+ // if a member of module is not inherited from Object class
+ // can not be declared protected
+ if ((parent is Module) && ((ModFlags & Modifiers.PROTECTED) != 0))
+ Report.Error (31066, Location,
+ "'Sub' or 'Function' inside a 'Module' can not be declared as " +
+ "'Protected' or 'Protected Friend'");
}
- }/* else if ((ModFlags & Modifiers.NEW) != 0)
+ }
+ /* else if ((ModFlags & Modifiers.NEW) != 0)
WarningNotHiding (parent);
*/
+
return true;
}
if (!CheckBase (parent))
return false;
+ if ((parent is Struct) && ((ModFlags & Modifiers.PROTECTED) != 0))
+ Report.Error (31067, Location,
+ "'Sub' or 'Function' inside a 'Structure' can not be declared as " +
+ "'Protected' or 'Protected Friend'");
+
CallingConventions cc = GetCallingConvention (parent is Class);
MethodData = new MethodData (this, null, MemberType, ParameterTypes,
ConstructorInfo parent_constructor;
Parameters parameters;
Location loc;
+ public bool implicit_initialization;
public ConstructorInitializer (ArrayList argument_list, Parameters parameters,
Location loc)
this.argument_list = argument_list;
this.parameters = parameters;
this.loc = loc;
+ this.implicit_initialization = false;
}
public ArrayList Arguments {
}
}
+ public ConstructorInfo ParentConstructor
+ {
+ get\r
+ {
+ return parent_constructor;
+ }
+ }
+
public bool Resolve (EmitContext ec)
{
Expression parent_constructor_group;
return true;
t = ec.ContainerType.BaseType;
- if (ec.ContainerType.IsValueType) {
+ if (ec.ContainerType.IsValueType){
Report.Error (522, loc,
"structs cannot call base class constructors");
return false;
}
- } else
+ }\r
+ else
t = ec.ContainerType;
-
+
parent_constructor_group = Expression.MemberLookup (
ec, t, t, ".ctor",
MemberTypes.Constructor,
loc);
if (parent_constructor_group == null){
- string s = String.Format ("'{0}': Can not find a constructor for this argument list", t);
- Report.Error (1501, loc, s);
+ Report.Error (30455, loc, "Class '" + t + "' can not find a constructor for this argument list" );
return false;
}
parent_constructor = (ConstructorInfo) Invocation.OverloadResolve (ec,
(MethodGroupExpr) parent_constructor_group, argument_list, loc);
-
- if (parent_constructor == null){
- string s = String.Format ("'{0}': Can not find a constructor for this argument list", t);
- Report.Error (1501, loc, s);
+
+ if (parent_constructor == null) {
+ if (this.implicit_initialization)
+ Report.Error (30148, loc, "Must declare 'MyBase.New' in the constructor " +\r
+ "of the class '" + ec.TypeContainer.Name + "' with appropriate arguments, since the base class '" +\r
+ t.FullName + "' does not contain a definition of 'New' without any parameter");
+ else
+ Report.Error (30455, loc, "Class '" + t + "' can not find a constructor for this argument list" );
+
return false;
}
-
+
return true;
}
Invocation.EmitCall (ec, true, false, ec.This, parent_constructor, argument_list, loc);
}
}
+
+
}
public class ConstructorBaseInitializer : ConstructorInitializer {
Initializer = init;
}
+ public Constructor (string name, int mod, Parameters args, ConstructorInitializer init, Location l)
+ : base (null, mod, AllowedModifiers, name, null, args, l)
+ {
+ Initializer = init;
+ }
+
//
// Returns true if this is a default constructor
//
MethodAttributes ca = (MethodAttributes.RTSpecialName |
MethodAttributes.SpecialName);
+ if (parent.EventHandlers != null) {
+ ArrayList hdlrs = parent.EventHandlers;
+ foreach(Statement stmt in hdlrs)
+ this.Block.AddStatement (stmt);
+ }
+
+
// Check if arguments were correct.
if (!DoDefineParameters (parent))
return false;
- if ((ModFlags & Modifiers.STATIC) != 0)
+ if ((ModFlags & Modifiers.STATIC) != 0) {
ca |= MethodAttributes.Static;
+
+ if (this.Parameters != Parameters.EmptyReadOnlyParameters)
+ Report.Error (
+ 30479, Location,
+ "Shared constructor can not have parameters");
+
+ if ((ModFlags & Modifiers.Accessibility) != 0)
+ Report.Error (
+ 30480, Location,
+ "Shared constructor can not be declared " +
+ "explicitly as public, private, friend or protected");
+
+ if (this.Initializer != null)
+ Report.Error (
+ 30043, Location,
+ "Keywords like MyBase, MyClass, Me are not " +
+ "valid inside a Shared Constructor");
+ }
else {
- if (parent is Struct && ParameterTypes.Length == 0){
+ if (parent is Struct && ParameterTypes.Length == 0) {
Report.Error (
- 568, Location,
+ 30629, Location,
"Structs can not contain explicit parameterless " +
"constructors");
return false;
if ((ModFlags & Modifiers.PUBLIC) != 0)
ca |= MethodAttributes.Public;
- else if ((ModFlags & Modifiers.PROTECTED) != 0){
+ else if ((ModFlags & Modifiers.PROTECTED) != 0) {
if ((ModFlags & Modifiers.INTERNAL) != 0)
ca |= MethodAttributes.FamORAssem;
else
ca |= MethodAttributes.Family;
- } else if ((ModFlags & Modifiers.INTERNAL) != 0)
+ }\r
+ else if ((ModFlags & Modifiers.INTERNAL) != 0)
ca |= MethodAttributes.Assembly;
else if (IsDefault ())
ca |= MethodAttributes.Public;
EmitContext ec = new EmitContext (parent, Location, ig, null, ModFlags, true);
if ((ModFlags & Modifiers.STATIC) == 0){
- if (parent is Class && Initializer == null)
+ if (parent is Class && Initializer == null) {
Initializer = new ConstructorBaseInitializer (
null, Parameters.EmptyReadOnlyParameters, parent.Location);
-
+ Initializer.implicit_initialization = true;
+ }
//
// Spec mandates that Initializers will not have
if ((ModFlags & Modifiers.STATIC) == 0)
parent.EmitFieldInitializers (ec);
}
- if (Initializer != null)
+
+ if (Initializer != null) {
+ if (this.ConstructorBuilder.Equals (Initializer.ParentConstructor))
+ Report.Error (
+ 30297, Location,
+ "A constructor can not call itself" );
+
Initializer.Emit (ec);
+ }
if ((ModFlags & Modifiers.STATIC) != 0)
parent.EmitFieldInitializers (ec);
: base (name, loc)
{
Type = type;
- ModFlags = Modifiers.Check (allowed_mod, mod, Modifiers.PRIVATE, loc);
+ ModFlags = Modifiers.Check (allowed_mod, mod, Modifiers.PUBLIC, loc);
OptAttributes = attrs;
}
//
// Check for explicit interface implementation
//
- if ((ExplicitInterfaceName == null) && (Name.IndexOf (".") != -1)){
+ if ((ExplicitInterfaceName == null) && (Name.IndexOf (".") != -1)) {
int pos = Name.LastIndexOf (".");
ExplicitInterfaceName = Name.Substring (0, pos);
// Modifiers allowed in a class declaration
// </summary>
const int AllowedModifiers =
- Modifiers.NEW |
+ Modifiers.SHADOWS |
Modifiers.PUBLIC |
Modifiers.PROTECTED |
Modifiers.INTERNAL |
Modifiers.PRIVATE |
Modifiers.STATIC |
- Modifiers.VOLATILE |
- Modifiers.UNSAFE |
+ // Modifiers.VOLATILE |
+ // Modifiers.UNSAFE |
Modifiers.READONLY;
public Field (Expression type, int mod, string name, Object expr_or_array_init,
if (t.IsPointer && !UnsafeOK (parent))
return false;
- if (RootContext.WarningLevel > 1){
- Type ptype = parent.TypeBuilder.BaseType;
+ Type ptype = parent.TypeBuilder.BaseType;
- // ptype is only null for System.Object while compiling corlib.
- if (ptype != null){
- TypeContainer.FindMembers (
- ptype, MemberTypes.Method,
- BindingFlags.Public |
- BindingFlags.Static | BindingFlags.Instance,
- System.Type.FilterName, Name);
+ // ptype is only null for System.Object while compiling corlib.
+ if (ptype != null){
+ MemberList list = TypeContainer.FindMembers (
+ ptype, MemberTypes.Field,
+ BindingFlags.Public |
+ BindingFlags.Static | BindingFlags.Instance,
+ System.Type.FilterName, Name);
+
+ if (RootContext.WarningLevel > 1){
+ if ((list.Count > 0) && ((ModFlags & Modifiers.SHADOWS) == 0)) \r
+ {
+ Report.Warning (
+ 40004, 2, Location,
+ "Variable '" + Name + "' should be declared " +
+ "Shadows since the base type '" + ptype.Name +
+ "' has a variable with same name");
+
+ ModFlags |= Modifiers.SHADOWS;
+ }
}
+ if (list.Count == 0)
+ // if a member of module is not inherited from Object class
+ // can not be declared protected
+ if ((parent is Module) && ((ModFlags & Modifiers.PROTECTED) != 0))
+ Report.Error (30593, Location,
+ "'Variable' inside a 'Module' can not be " +
+ "declared as 'Protected'");
}
+
+ if ((parent is Struct) && ((ModFlags & Modifiers.PROTECTED) != 0))
+ Report.Error (30435, Location,
+ "'Variable' inside a 'Structure' can not be " +
+ "declared as 'Protected'");
if ((ModFlags & Modifiers.VOLATILE) != 0){
if (!t.IsClass){
//
// Checks our base implementation if any
//
- protected override bool CheckBase (TypeContainer parent)
+ protected override bool CheckBase (TypeContainer container)
{
+ base.CheckBase (container);
+
// Check whether arguments were correct.
- if (!DoDefineParameters (parent))
+ if (!DoDefineParameters (container))
return false;
if (IsExplicitImpl)
return true;
+ MethodSignature ms = new MethodSignature (Name, null, ParameterTypes);
+ if (!IsOperator) \r
+ {
+ MemberList mi_this;
+
+ mi_this = TypeContainer.FindMembers (
+ container.TypeBuilder, MemberTypes.Property,
+ BindingFlags.NonPublic | BindingFlags.Public |
+ BindingFlags.Static | BindingFlags.Instance |
+ BindingFlags.DeclaredOnly,
+ MethodSignature.method_signature_filter, ms);
+
+ if (mi_this.Count > 0) {
+ Report.Error (111, Location, "Class `" + container.Name + "' " +
+ "already defines a member called `" + Name + "' " +
+ "with the same parameter types");
+ return false;
+ }
+ }
+
+ if (container is Interface)
+ return true;
+
string report_name;
- MethodSignature ms, base_ms;
+ MethodSignature base_ms;
if (this is Indexer) {
string name, base_name;
report_name = "this";
- name = TypeManager.IndexerPropertyName (parent.TypeBuilder);
+ name = TypeManager.IndexerPropertyName (container.TypeBuilder);
ms = new MethodSignature (name, null, ParameterTypes);
- base_name = TypeManager.IndexerPropertyName (parent.TypeBuilder.BaseType);
+ base_name = TypeManager.IndexerPropertyName (container.TypeBuilder.BaseType);
base_ms = new MethodSignature (base_name, null, ParameterTypes);
} else {
report_name = Name;
ms = base_ms = new MethodSignature (Name, null, ParameterTypes);
}
- MemberList props_this;
-
- props_this = TypeContainer.FindMembers (
- parent.TypeBuilder, MemberTypes.Property,
- BindingFlags.NonPublic | BindingFlags.Public |
- BindingFlags.Static | BindingFlags.Instance |
- BindingFlags.DeclaredOnly,
- MethodSignature.method_signature_filter, ms);
-
- if (props_this.Count > 0) {
- Report.Error (111, Location, "Class `" + parent.Name + "' " +
- "already defines a member called `" + report_name + "' " +
- "with the same parameter types");
- return false;
- }
-
//
- // Find properties with the same name on the base class
+ // Verify if the parent has a type with the same name, and then
+ // check whether we have to create a new slot for it or not.
//
- MemberList props;
- MemberList props_static = TypeContainer.FindMembers (
- parent.TypeBuilder.BaseType, MemberTypes.Property,
+ Type ptype = container.TypeBuilder.BaseType;
+
+ MemberInfo parent_member = null;
+ MemberList mi, mi_static, mi_instance;
+
+ mi_static = TypeContainer.FindMembers (
+ ptype, MemberTypes.Property,
BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static,
- MethodSignature.inheritable_property_signature_filter, base_ms);
+ MethodSignature.inheritable_method_signature_filter, ms);
- MemberList props_instance = TypeContainer.FindMembers (
- parent.TypeBuilder.BaseType, MemberTypes.Property,
+ mi_instance = TypeContainer.FindMembers (
+ ptype, MemberTypes.Property,
BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance,
- MethodSignature.inheritable_property_signature_filter,
- base_ms);
+ MethodSignature.inheritable_method_signature_filter,
+ ms);
- //
- // Find if we have anything
- //
- if (props_static.Count > 0)
- props = props_static;
- else if (props_instance.Count > 0)
- props = props_instance;
+ if (mi_instance.Count > 0) {
+ mi = mi_instance;
+ } else if (mi_static.Count > 0)
+ mi = mi_static;
else
- props = null;
+ mi = null;
+ if (mi != null && mi.Count > 0)\r
+ parent_member = (MethodInfo) mi [0];
+\r
+ if (parent_member is PropertyInfo) {
+ PropertyInfo parent_property = (PropertyInfo)parent_member;
- //
- // If we have something on the base.
- if (props != null && props.Count > 0){
- PropertyInfo pi = (PropertyInfo) props [0];
+ string name = parent_property.DeclaringType.Name + "." +
+ parent_property.Name;
- MethodInfo inherited_get = TypeManager.GetPropertyGetter (pi);
- MethodInfo inherited_set = TypeManager.GetPropertySetter (pi);
+ MethodInfo get, set, parent_method;
+ get = parent_property.GetGetMethod (true);
+ set = parent_property.GetSetMethod (true);
- MethodInfo reference = inherited_get == null ?
- inherited_set : inherited_get;
-
- if (reference != null) {
- string name = reference.DeclaringType.Name + "." + report_name;
-
- if (!CheckMethodAgainstBase (parent, flags, reference, name))
- return false;
- }
+ if (get != null)
+ parent_method = get;
+ else if (set != null)
+ parent_method = set;
+ else
+ throw new Exception ("Internal error!");
- if (((ModFlags & Modifiers.NEW) == 0) && (pi.PropertyType != MemberType)) {
- Report.Error (508, parent.MakeName (Name) + ": cannot " +
- "change return type when overriding inherited " +
- "member `" + pi.DeclaringType + "." + pi.Name + "'");
+ if (!CheckMethodAgainstBase (container, flags, parent_method, name))
return false;
+
+ if ((ModFlags & Modifiers.NEW) == 0) {
+ Type parent_type = TypeManager.TypeToCoreType (
+ parent_property.PropertyType);
+
+ if (parent_type != MemberType) {
+ Report.Error (
+ 508, Location, container.MakeName (Name) + ": cannot " +
+ "change return type when overriding " +
+ "inherited member " + name);
+ return false;
+ }
}
- } else {
+ } else if (parent_member == null) {
/*if ((ModFlags & Modifiers.NEW) != 0)
- WarningNotHiding (parent);*/
-
- if ((ModFlags & Modifiers.OVERRIDE) != 0){
+ WarningNotHiding (container);
+ */
+ if ((ModFlags & Modifiers.OVERRIDE) != 0) {
if (this is Indexer)
Report.Error (115, Location,
- parent.MakeName (Name) +
- " no suitable indexers found to override");
+ container.MakeName (Name) +
+ " no suitable indexers found to override");
else
Report.Error (115, Location,
- parent.MakeName (Name) +
- " no suitable properties found to override");
+ container.MakeName (Name) +
+ " no suitable properties found to override");
return false;
}
+
+ if ((ModFlags & ( Modifiers.NEW | Modifiers.SHADOWS | Modifiers.OVERRIDE )) == 0) {
+ if ((ModFlags & Modifiers.NONVIRTUAL) != 0) {
+ Report.Error (31088, Location,
+ container.MakeName (Name) + " : Cannot " +
+ "be declared NotOverridable since this method is " +
+ "not maked as Overrides");
+ }
+ }
+ // if a member of module is not inherited from Object class
+ // can not be declared protected
+ if ((container is Module) && ((ModFlags & Modifiers.PROTECTED) != 0))
+ Report.Error (31066, Location,
+ "'Property' inside a 'Module' can not be declared as " +
+ "'Protected' or 'Protected Friend'");
}
return true;
}
Modifiers.UNSAFE |
Modifiers.EXTERN |
Modifiers.VIRTUAL |
+ Modifiers.NONVIRTUAL |
Modifiers.DEFAULT |
Modifiers.READONLY |
Modifiers.WRITEONLY |
Parameter [] g_parms, s_parms;
InternalParameters g_ip=null, s_ip=null;
+ if ((parent is Struct) && ((ModFlags & Modifiers.PROTECTED) != 0))
+ Report.Error (30435, Location,
+ "'Property' inside a 'Structure' can not be declared as " +
+ "'Protected' or 'Protected Friend'");
+
if (!DoDefine (parent))
return false;
flags |= MethodAttributes.HideBySig | MethodAttributes.SpecialName;
- if (Get != null) {
- if (get_params == Parameters.EmptyReadOnlyParameters)
- {
+ if (Get == null) {
+ if ((ModFlags & Modifiers.WRITEONLY) == 0)
+ Report.Error (
+ 30124, Location,
+ "Property without 'Get' accessor must have a 'WriteOnly' modifier");
+ }
+ else {
+ if (get_params == Parameters.EmptyReadOnlyParameters) {
g_parameters = TypeManager.NoTypes;
g_ip = new InternalParameters (
parent, Parameters.EmptyReadOnlyParameters);
- }
- else
- {
+ } else {
g_parameters = new Type [get_params.FixedParameters.Length];
- for (int i = 0; i < get_params.FixedParameters.Length; i ++)
- {
+ for (int i = 0; i < get_params.FixedParameters.Length; i ++) {
g_parameters[i] = get_params.FixedParameters[i].ParameterType;
}
g_parms = new Parameter [get_params.FixedParameters.Length];
- for (int i = 0; i < get_params.FixedParameters.Length; i ++)
- {
+ for (int i = 0; i < get_params.FixedParameters.Length; i ++) {
Parameter tp = get_params.FixedParameters[i];
g_parms[i] = new Parameter (tp.TypeName, tp.Name,
Parameter.Modifier.NONE, null);
GetBuilder = GetData.MethodBuilder;
}
- if (Set != null) {
+ if (Set == null) {
+ if ((ModFlags & Modifiers.READONLY) == 0)
+ Report.Error (
+ 30124, Location,
+ "Property without 'Set' accessor must have a 'ReadOnly' modifier");
+
+ }
+ else \r
+ {
if (set_params == Parameters.EmptyReadOnlyParameters)
{
s_parameters = new Type [1];
s_parameters [0] = MemberType;
s_parms = new Parameter [1];
- s_parms [0] = new Parameter (Type, /* was "value" */ set_parameter_name,
+ s_parms [0] = new Parameter (Type, set_parameter_name,
Parameter.Modifier.NONE, null);
- }
- else
- {
+ } else {
s_parameters = new Type [set_params.FixedParameters.Length];
- for (int i = 0; i < set_params.FixedParameters.Length; i ++)
- {
+ for (int i = 0; i < set_params.FixedParameters.Length; i ++) {
s_parameters[i] = set_params.FixedParameters[i].ParameterType;
}
s_parms = new Parameter [set_params.FixedParameters.Length];
- for (int i = 0; i < set_params.FixedParameters.Length; i ++)
- {
+ for (int i = 0; i < set_params.FixedParameters.Length; i ++) {
Parameter tp = set_params.FixedParameters[i];
s_parms[i] = new Parameter (tp.TypeName, tp.Name,
- Parameter.Modifier.NONE, null);
+ Parameter.Modifier.NONE, null);
}
}
s_ip = new InternalParameters (
parent, new Parameters (s_parms, null, Location));
-
SetData = new MethodData (this, "set", TypeManager.void_type,
- s_parameters, s_ip, CallingConventions.Standard,
- Set.OptAttributes, ModFlags, flags, false);
+ s_parameters, s_ip, CallingConventions.Standard,
+ Set.OptAttributes, ModFlags, flags, false);
if (!SetData.Define (parent))
return false;
SetBuilder = SetData.MethodBuilder;
SetBuilder.DefineParameter (1, ParameterAttributes.None,
- /* was "value" */ set_parameter_name);
+ set_parameter_name);
}
// FIXME - PropertyAttributes.HasDefault ?
PropertyBuilder = parent.TypeBuilder.DefineProperty (
Name, prop_attr, MemberType, null);
- if (Get != null)
- PropertyBuilder.SetGetMethod (GetBuilder);
-
- if (Set != null)
- PropertyBuilder.SetSetMethod (SetBuilder);
+ PropertyBuilder.SetGetMethod (GetBuilder);
+ PropertyBuilder.SetSetMethod (SetBuilder);
//
// HACK for the reasons exposed above
return false;
if (!MemberType.IsSubclassOf (TypeManager.delegate_type)) {
- Report.Error (66, Location, "'" + parent.Name + "." + Name +
+ Report.Error (31044, Location, "'" + parent.Name + "." + Name +
"' : event must be of a delegate type");
return false;
}