public abstract class TypeContainer : MemberCore
{
public readonly MemberKind Kind;
- public readonly string Basename;
protected List<TypeContainer> containers;
: base (parent, name, attrs)
{
this.Kind = kind;
- if (name != null)
- this.Basename = name.Basename;
-
defined_names = new Dictionary<string, MemberCore> ();
}
public virtual void AddPartial (TypeDefinition next_part)
{
MemberCore mc;
- (PartialContainer ?? this).defined_names.TryGetValue (next_part.Basename, out mc);
+ (PartialContainer ?? this).defined_names.TryGetValue (next_part.MemberName.Basename, out mc);
AddPartial (next_part, mc as TypeDefinition);
}
return MemberName.GetSignatureForError ();
}
- public string GetSignatureForMetadata ()
+ public virtual string GetSignatureForMetadata ()
{
- if (Parent is TypeDefinition) {
- return Parent.GetSignatureForMetadata () + "+" + TypeNameParser.Escape (MemberName.Basename);
- }
-
var sb = new StringBuilder ();
CreateMetadataName (sb);
return sb.ToString ();
containers.Remove (cont);
var tc = Parent == Module ? Module : this;
- tc.defined_names.Remove (cont.Basename);
+ tc.defined_names.Remove (cont.MemberName.Basename);
}
public virtual void VerifyMembers ()
return tc.GetSignatureForError ();
}
- public ExtensionMethodCandidates LookupExtensionMethod (TypeSpec extensionType, string name, int arity)
+ public ExtensionMethodCandidates LookupExtensionMethod (string name, int arity)
{
return null;
}
public override void AddTypeContainer (TypeContainer tc)
{
- AddNameToContainer (tc, tc.Basename);
+ AddNameToContainer (tc, tc.MemberName.Basename);
base.AddTypeContainer (tc);
}
}
}
- public virtual void RegisterFieldForInitialization (MemberCore field, FieldInitializer expression)
+ public void RegisterFieldForInitialization (MemberCore field, FieldInitializer expression)
{
if (IsPartialPart)
PartialContainer.RegisterFieldForInitialization (field, expression);
initialized_static_fields.Add (expression);
} else {
+ if (Kind == MemberKind.Struct) {
+ if (Compiler.Settings.Version != LanguageVersion.Experimental) {
+ Report.Error (573, expression.Location, "'{0}': Structs cannot have instance property or field initializers",
+ GetSignatureForError ());
+ }
+ }
+
if (initialized_fields == null)
initialized_fields = new List<FieldInitializer> (4);
//
// Field is re-initialized to its default value => removed
//
- if (fi.IsDefaultInitializer && ec.Module.Compiler.Settings.Optimize)
+ if (fi.IsDefaultInitializer && Kind != MemberKind.Struct && ec.Module.Compiler.Settings.Optimize)
continue;
ec.AssignmentInfoOffset += fi.AssignmentOffset;
}
}
+ public override string GetSignatureForMetadata ()
+ {
+ if (Parent is TypeDefinition) {
+ return Parent.GetSignatureForMetadata () + "+" + TypeNameParser.Escape (FilterNestedName (MemberName.Basename));
+ }
+
+ return base.GetSignatureForMetadata ();
+ }
+
public virtual void SetBaseTypes (List<FullNamedExpression> baseTypes)
{
type_bases = baseTypes;
CreateMetadataName (sb);
TypeBuilder = Module.CreateBuilder (sb.ToString (), TypeAttr, type_size);
} else {
- TypeBuilder = parent_def.TypeBuilder.DefineNestedType (Basename, TypeAttr, null, type_size);
+ TypeBuilder = parent_def.TypeBuilder.DefineNestedType (FilterNestedName (MemberName.Basename), TypeAttr, null, type_size);
}
if (DeclaringAssembly.Importer != null)
return true;
}
+ public static string FilterNestedName (string name)
+ {
+ //
+ // SRE API does not handle namespaces and types separately but
+ // determine that from '.' in name. That's problematic because
+ // dot is valid character for type name. By replacing any '.'
+ // in name we avoid any ambiguities and never emit metadata
+ // namespace for nested types
+ //
+ return name.Replace ('.', '_');
+ }
+
string[] CreateTypeParameters (TypeParameters parentAllTypeParameters)
{
string[] names;
public SourceMethodBuilder CreateMethodSymbolEntry ()
{
- if (Module.DeclaringAssembly.SymbolWriter == null)
+ if (Module.DeclaringAssembly.SymbolWriter == null || (ModFlags & Modifiers.DEBUGGER_HIDDEN) != 0)
return null;
var source_file = GetCompilationSourceFile ();
// defined after current container
//
if (class_partial_parts != null) {
- foreach (var pp in class_partial_parts)
+ foreach (var pp in class_partial_parts) {
+ if (pp.PrimaryConstructorBaseArguments != null)
+ PrimaryConstructorBaseArguments = pp.PrimaryConstructorBaseArguments;
+
pp.DoDefineBaseType ();
+ }
}
foreach (var member in members) {
var pbm = member as PropertyBasedMember;
- if (pbm != null)
+ if (pbm != null) {
pbm.PrepareEmit ();
+ continue;
+ }
- var pm = member as IParametersMember;
- if (pm != null) {
- var mc = member as MethodOrOperator;
- if (mc != null) {
- mc.PrepareEmit ();
- }
-
- var p = pm.Parameters;
- if (p.IsEmpty)
- continue;
-
- ((ParametersCompiled) p).ResolveDefaultValues (member);
+ var mc = member as MethodCore;
+ if (mc != null) {
+ mc.PrepareEmit ();
continue;
}
this.spec = spec;
current_type = null;
+ if (class_partial_parts != null) {
+ foreach (var part in class_partial_parts)
+ part.spec = spec;
+ }
}
public override void RemoveContainer (TypeContainer cont)
{
base.RemoveContainer (cont);
Members.Remove (cont);
- Cache.Remove (cont.Basename);
+ Cache.Remove (cont.MemberName.Basename);
}
protected virtual bool DoResolveTypeParameters ()
if (Kind == MemberKind.Class)
c.Initializer = new GeneratedBaseInitializer (Location, PrimaryConstructorBaseArguments);
- if (PrimaryConstructorParameters != null && !is_static)
+ if (PrimaryConstructorParameters != null && !is_static) {
c.IsPrimaryConstructor = true;
+ c.caching_flags |= Flags.MethodOverloadsExist;
+ }
AddConstructor (c, true);
if (PrimaryConstructorBlock == null) {
- c.Block = new ToplevelBlock (Compiler, c.ParameterInfo, Location) {
+ c.Block = new ToplevelBlock (Compiler, parameters, Location) {
IsCompilerGenerated = true
};
} else {
CheckProtectedModifier ();
if (PrimaryConstructorParameters != null) {
+
foreach (Parameter p in PrimaryConstructorParameters.FixedParameters) {
if (p.Name == MemberName.Name) {
Report.Error (8039, p.Location, "Primary constructor of type `{0}' has parameter of same name as containing type",
if (ff == null)
continue;
- ff.CharSet = (CharSet) System.Enum.Parse (typeof (CharSet), value.GetValue ().ToString ());
+ ff.CharSetValue = (CharSet) System.Enum.Parse (typeof (CharSet), value.GetValue ().ToString ());
}
}
}
protected override bool DoDefineMembers ()
{
- if (PrimaryConstructorParameters != null)
+ var res = base.DoDefineMembers ();
+
+ if (PrimaryConstructorParameters != null || (initialized_fields != null && !HasUserDefaultConstructor ())) {
generated_primary_constructor = DefineDefaultConstructor (false);
+ generated_primary_constructor.Define ();
+ }
- return base.DoDefineMembers ();
+ return res;
}
public override void Emit ()
base.Emit ();
}
- bool HasExplicitConstructor ()
+ bool HasUserDefaultConstructor ()
{
- foreach (var m in Members) {
+ foreach (var m in PartialContainer.Members) {
var c = m as Constructor;
if (c == null)
continue;
- if (!c.ParameterInfo.IsEmpty)
+ if (!c.IsStatic && c.ParameterInfo.IsEmpty)
return true;
}
base_type = Compiler.BuiltinTypes.ValueType;
return ifaces;
}
-
- public override void RegisterFieldForInitialization (MemberCore field, FieldInitializer expression)
- {
- if ((field.ModFlags & Modifiers.STATIC) == 0 && !HasExplicitConstructor ()) {
- Report.Error (8054, field.Location, "`{0}': Structs without explicit constructors cannot contain members with initializers",
- field.GetSignatureForError ());
-
- return;
- }
-
- base.RegisterFieldForInitialization (field, expression);
- }
}
/// <summary>
ModFlags |= Modifiers.NEW;
if (!IsCompilerGenerated) {
Report.SymbolRelatedToPreviousError (base_member);
- if (!IsInterface && (base_member.Modifiers & (Modifiers.ABSTRACT | Modifiers.VIRTUAL | Modifiers.OVERRIDE)) != 0) {
+ if ((base_member.Kind & MemberKind.NestedMask) == 0 && !IsInterface && (base_member.Modifiers & (Modifiers.ABSTRACT | Modifiers.VIRTUAL | Modifiers.OVERRIDE)) != 0) {
Report.Warning (114, 2, Location, "`{0}' hides inherited member `{1}'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword",
GetSignatureForError (), base_member.GetSignatureForError ());
} else {
}
if (!IsInterface && base_member.IsAbstract && !overrides && !IsStatic) {
- Report.SymbolRelatedToPreviousError (base_member);
- Report.Error (533, Location, "`{0}' hides inherited abstract member `{1}'",
- GetSignatureForError (), base_member.GetSignatureForError ());
+ switch (base_member.Kind) {
+ case MemberKind.Event:
+ case MemberKind.Indexer:
+ case MemberKind.Method:
+ case MemberKind.Property:
+ Report.SymbolRelatedToPreviousError (base_member);
+ Report.Error (533, Location, "`{0}' hides inherited abstract member `{1}'",
+ GetSignatureForError (), base_member.GetSignatureForError ());
+ break;
+ }
}
}
public override string GetSignatureForDocumentation ()
{
if (IsExplicitImpl)
- return Parent.GetSignatureForDocumentation () + "." + InterfaceType.GetExplicitNameSignatureForDocumentation () + "#" + ShortName;
+ return Parent.GetSignatureForDocumentation () + "." + InterfaceType.GetSignatureForDocumentation (true) + "#" + ShortName;
return Parent.GetSignatureForDocumentation () + "." + ShortName;
}
projects / mono.git / blobdiff