protected CompilerGeneratedContainer (TypeContainer parent, MemberName name, Modifiers mod, MemberKind kind)
: base (parent, name, null, kind)
{
Debug.Assert ((mod & Modifiers.AccessibilityMask) != 0);
ModFlags = mod | Modifiers.COMPILER_GENERATED | Modifiers.SEALED;
spec = new TypeSpec (Kind, null, this, null, ModFlags);
}
public Delegate (TypeContainer parent, FullNamedExpression type, Modifiers mod_flags, MemberName name, ParametersCompiled param_list,
Attributes attrs)
: base (parent, name, attrs, MemberKind.Delegate)
{
this.ReturnType = type;
ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod_flags,
IsTopLevel ? Modifiers.INTERNAL :
Modifiers.PRIVATE, name.Location, Report);
parameters = param_list;
spec = new TypeSpec (Kind, null, this, null, ModFlags | Modifiers.SEALED);
}
public virtual void Define (TypeContainer parent)
{
var container = parent.PartialContainer;
//
// Check for custom access modifier
//
if ((ModFlags & Modifiers.AccessibilityMask) == 0) {
ModFlags |= method.ModFlags;
flags = method.flags;
} else {
CheckModifiers (ModFlags);
ModFlags |= (method.ModFlags & (~Modifiers.AccessibilityMask));
ModFlags |= Modifiers.PROPERTY_CUSTOM;
if (container.Kind == MemberKind.Interface) {
Report.Error (275, Location, "`{0}': accessibility modifiers may not be used on accessors in an interface",
GetSignatureForError ());
} else if ((ModFlags & Modifiers.PRIVATE) != 0) {
if ((method.ModFlags & Modifiers.ABSTRACT) != 0) {
Report.Error (442, Location, "`{0}': abstract properties cannot have private accessors", GetSignatureForError ());
}
ModFlags &= ~Modifiers.VIRTUAL;
}
flags = ModifiersExtensions.MethodAttr (ModFlags) | MethodAttributes.SpecialName;
}
CheckAbstractAndExtern (block != null);
CheckProtectedModifier ();
if (block != null) {
if (block.IsIterator)
Iterator.CreateIterator (this, Parent.PartialContainer, ModFlags);
if (Compiler.Settings.WriteMetadataOnly)
block = null;
}
}
public override void AddTypeContainer (TypeContainer tc)
{
AddNameToContainer (tc, tc.MemberName.Basename);
base.AddTypeContainer (tc);
}
protected TypeDefinition (TypeContainer parent, MemberName name, Attributes attrs, MemberKind kind)
: base (parent, name, attrs, kind)
{
PartialContainer = this;
members = new List<MemberCore> ();
}
public virtual void RemoveContainer (TypeContainer cont)
{
if (containers != null)
containers.Remove (cont);
var tc = Parent == Module ? Module : this;
tc.defined_names.Remove (cont.MemberName.Basename);
}
protected ClassOrStruct (TypeContainer parent, MemberName name, Attributes attrs, MemberKind kind)
: base (parent, name, attrs, kind)
{
}
public virtual void AddTypeContainer (TypeContainer tc)
{
AddTypeContainerMember (tc);
var tparams = tc.MemberName.TypeParameters;
if (tparams != null && tc.PartialContainer != null) {
var td = (TypeDefinition) tc;
for (int i = 0; i < tparams.Count; ++i) {
var tp = tparams[i];
if (tp.MemberName == null)
continue;
td.AddNameToContainer (tp, tp.Name);
}
}
}
void case_25()
#line 559 "cs-parser.jay"
{
if (yyVals[0+yyTop] != null)
lbag.AddLocation (current_container, GetLocation (yyVals[-9+yyTop]), GetLocation (yyVals[-6+yyTop]), GetLocation (yyVals[-1+yyTop]), GetLocation (yyVals[0+yyTop]));
else
lbag.AddLocation (current_container, GetLocation (yyVals[-9+yyTop]), GetLocation (yyVals[-6+yyTop]), GetLocation (yyVals[-1+yyTop]));
current_container = current_namespace = current_namespace.Parent;
}
protected MemberCore (TypeContainer parent, MemberName name, Attributes attrs)
{
this.Parent = parent;
member_name = name;
caching_flags = Flags.Obsolete_Undetected | Flags.ClsCompliance_Undetected | Flags.HasCompliantAttribute_Undetected | Flags.Excluded_Undetected;
AddAttributes (attrs, this);
}
protected CompilerGeneratedContainer (TypeContainer parent, MemberName name, Modifiers mod)
: this (parent, name, mod, MemberKind.Class)
{
}
public static AnonymousTypeClass Create (TypeContainer parent, IList<AnonymousTypeParameter> parameters, Location loc)
{
string name = ClassNamePrefix + parent.Module.CounterAnonymousTypes++;
ParametersCompiled all_parameters;
TypeParameters tparams = null;
SimpleName[] t_args;
if (parameters.Count == 0) {
all_parameters = ParametersCompiled.EmptyReadOnlyParameters;
t_args = null;
} else {
t_args = new SimpleName[parameters.Count];
tparams = new TypeParameters ();
Parameter[] ctor_params = new Parameter[parameters.Count];
for (int i = 0; i < parameters.Count; ++i) {
AnonymousTypeParameter p = parameters[i];
for (int ii = 0; ii < i; ++ii) {
if (parameters[ii].Name == p.Name) {
parent.Compiler.Report.Error (833, parameters[ii].Location,
"`{0}': An anonymous type cannot have multiple properties with the same name",
p.Name);
p = new AnonymousTypeParameter (null, "$" + i.ToString (), p.Location);
parameters[i] = p;
break;
}
}
t_args[i] = new SimpleName ("<" + p.Name + ">__T", p.Location);
tparams.Add (new TypeParameter (i, new MemberName (t_args[i].Name, p.Location), null, null, Variance.None));
ctor_params[i] = new Parameter (t_args[i], p.Name, Parameter.Modifier.NONE, null, p.Location);
}
all_parameters = new ParametersCompiled (ctor_params);
}
//
// Create generic anonymous type host with generic arguments
// named upon properties names
//
AnonymousTypeClass a_type = new AnonymousTypeClass (parent.Module, new MemberName (name, tparams, loc), parameters, loc);
Constructor c = new Constructor (a_type, name, Modifiers.PUBLIC | Modifiers.DEBUGGER_HIDDEN,
null, all_parameters, loc);
c.Block = new ToplevelBlock (parent.Module.Compiler, c.ParameterInfo, loc);
//
// Create fields and constructor body with field initialization
//
bool error = false;
for (int i = 0; i < parameters.Count; ++i) {
AnonymousTypeParameter p = parameters [i];
Field f = new Field (a_type, t_args [i], Modifiers.PRIVATE | Modifiers.READONLY | Modifiers.DEBUGGER_HIDDEN,
new MemberName ("<" + p.Name + ">", p.Location), null);
if (!a_type.AddField (f)) {
error = true;
continue;
}
c.Block.AddStatement (new StatementExpression (
new SimpleAssign (new MemberAccess (new This (p.Location), f.Name),
c.Block.GetParameterReference (i, p.Location))));
ToplevelBlock get_block = new ToplevelBlock (parent.Module.Compiler, p.Location);
get_block.AddStatement (new Return (
new MemberAccess (new This (p.Location), f.Name), p.Location));
Property prop = new Property (a_type, t_args [i], Modifiers.PUBLIC,
new MemberName (p.Name, p.Location), null);
prop.Get = new Property.GetMethod (prop, 0, null, p.Location);
prop.Get.Block = get_block;
a_type.AddMember (prop);
}
if (error)
return null;
a_type.AddConstructor (c);
return a_type;
}
public Enum (TypeContainer parent, FullNamedExpression type, Modifiers mod_flags, MemberName name, Attributes attrs)
: base (parent, name, attrs, MemberKind.Enum)
{
underlying_type_expr = type;
var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE;
ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod_flags, accmods, Location, Report);
spec = new EnumSpec (null, this, null, null, ModFlags);
}
public override void Define (TypeContainer ds)
{
CheckAbstractAndExtern (block != null);
base.Define (ds);
}
public CSharpParser (SeekableStreamReader reader, CompilationSourceFile file, Report report, ParserSession session)
{
this.file = file;
current_container = current_namespace = file;
this.module = file.Module;
this.compiler = file.Compiler;
this.settings = compiler.Settings;
this.report = report;
lang_version = settings.Version;
yacc_verbose_flag = settings.VerboseParserFlag;
doc_support = settings.DocumentationFile != null;
lexer = new Tokenizer (reader, file, session, report);
oob_stack = new Stack<object> ();
lbag = session.LocationsBag;
use_global_stacks = session.UseJayGlobalArrays;
parameters_bucket = session.ParametersStack;
}
public override void RemoveContainer (TypeContainer cont)
{
base.RemoveContainer (cont);
NS.RemoveContainer (cont);
}
void case_23()
#line 526 "cs-parser.jay"
{
Attributes attrs = (Attributes) yyVals[-2+yyTop];
var name = (MemberName) yyVals[0+yyTop];
if (attrs != null) {
bool valid_global_attrs = true;
if ((current_namespace.DeclarationFound || current_namespace != file)) {
valid_global_attrs = false;
} else {
foreach (var a in attrs.Attrs) {
if (a.ExplicitTarget == "assembly" || a.ExplicitTarget == "module")
continue;
valid_global_attrs = false;
break;
}
}
if (!valid_global_attrs)
report.Error (1671, name.Location, "A namespace declaration cannot have modifiers or attributes");
}
module.AddAttributes (attrs, current_namespace);
var ns = new NamespaceContainer (name, current_namespace);
current_namespace.AddTypeContainer (ns);
current_container = current_namespace = ns;
}
public void RemoveContainer (TypeContainer tc)
{
IList<TypeSpec> found;
if (types.TryGetValue (tc.MemberName.Name, out found)) {
for (int i = 0; i < found.Count; ++i) {
if (tc.MemberName.Arity != found [i].Arity)
continue;
if (found.Count == 1)
types.Remove (tc.MemberName.Name);
else
found.RemoveAt (i);
break;
}
}
cached_types.Remove (tc.MemberName.Basename);
}
public override void RemoveContainer (TypeContainer cont)
{
base.RemoveContainer (cont);
Members.Remove (cont);
Cache.Remove (cont.MemberName.Basename);
}
public override void AddTypeContainer (TypeContainer tc)
{
var mn = tc.MemberName;
var name = mn.Basename;
while (mn.Left != null) {
mn = mn.Left;
name = mn.Name;
}
var names_container = Parent == null ? Module : (TypeContainer) this;
MemberCore mc;
if (names_container.DefinedNames.TryGetValue (name, out mc)) {
if (tc is NamespaceContainer && mc is NamespaceContainer) {
AddTypeContainerMember (tc);
return;
}
Report.SymbolRelatedToPreviousError (mc);
if ((mc.ModFlags & Modifiers.PARTIAL) != 0 && (tc is ClassOrStruct || tc is Interface)) {
Error_MissingPartialModifier (tc);
} else {
Report.Error (101, tc.Location, "The namespace `{0}' already contains a definition for `{1}'",
GetSignatureForError (), mn.GetSignatureForError ());
}
} else {
names_container.DefinedNames.Add (name, tc);
var tdef = tc.PartialContainer;
if (tdef != null) {
//
// Same name conflict in different namespace containers
//
var conflict = ns.GetAllTypes (name);
if (conflict != null) {
foreach (var e in conflict) {
if (e.Arity == mn.Arity) {
mc = (MemberCore) e.MemberDefinition;
break;
}
}
}
if (mc != null) {
Report.SymbolRelatedToPreviousError (mc);
Report.Error (101, tc.Location, "The namespace `{0}' already contains a definition for `{1}'",
GetSignatureForError (), mn.GetSignatureForError ());
} else {
ns.AddType (Module, tdef.Definition);
}
}
}
base.AddTypeContainer (tc);
}
protected virtual void AddTypeContainerMember (TypeContainer tc)
{
containers.Add (tc);
}
public static bool CheckImplementingMethodConstraints (TypeContainer container, MethodSpec method, MethodSpec baseMethod)
{
var tparams = method.Constraints;
var base_tparams = baseMethod.Constraints;
for (int i = 0; i < tparams.Length; ++i) {
if (!tparams[i].HasSameConstraintsImplementation (base_tparams[i])) {
container.Compiler.Report.SymbolRelatedToPreviousError (method);
container.Compiler.Report.SymbolRelatedToPreviousError (baseMethod);
// Using container location because the interface can be implemented
// by base class
var tp = (tparams [i].MemberDefinition as MemberCore) ?? container;
container.Compiler.Report.Error (425, tp.Location,
"The constraints for type parameter `{0}' of method `{1}' must match the constraints for type parameter `{2}' of interface method `{3}'. Consider using an explicit interface implementation instead",
tparams[i].GetSignatureForError (), method.GetSignatureForError (),
base_tparams[i].GetSignatureForError (), baseMethod.GetSignatureForError ());
return false;
}
}
return true;
}
public Interface (TypeContainer parent, MemberName name, Modifiers mod, Attributes attrs)
: base (parent, name, attrs, MemberKind.Interface)
{
var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE;
this.ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod, accmods, name.Location, Report);
spec = new TypeSpec (Kind, null, this, null, ModFlags);
}
void case_1086()
#line 7387 "cs-parser.jay"
{
current_container = current_type = new Class (current_container, new MemberName ("<InteractiveExpressionClass>"), Modifiers.PUBLIC, null);
/* (ref object retval)*/
Parameter [] mpar = new Parameter [1];
mpar [0] = new Parameter (new TypeExpression (compiler.BuiltinTypes.Object, Location.Null), "$retval", Parameter.Modifier.REF, null, Location.Null);
ParametersCompiled pars = new ParametersCompiled (mpar);
var mods = Modifiers.PUBLIC | Modifiers.STATIC;
if (settings.Unsafe)
mods |= Modifiers.UNSAFE;
current_local_parameters = pars;
var method = new InteractiveMethod (
current_type,
new TypeExpression (compiler.BuiltinTypes.Void, Location.Null),
mods,
pars);
current_type.AddMember (method);
oob_stack.Push (method);
interactive_async = false;
++lexer.parsing_block;
start_block (lexer.Location);
}
public BaseContext (TypeContainer tc)
{
this.tc = tc;
}
void push_current_container (TypeDefinition tc, object partial_token)
{
if (module.Evaluator != null){
tc.Definition.Modifiers = tc.ModFlags = (tc.ModFlags & ~Modifiers.AccessibilityMask) | Modifiers.PUBLIC;
if (undo == null)
undo = new Undo ();
undo.AddTypeContainer (current_container, tc);
}
if (partial_token != null)
current_container.AddPartial (tc);
else
current_container.AddTypeContainer (tc);
++lexer.parsing_declaration;
current_container = tc;
current_type = tc;
}
protected TypeContainer (TypeContainer parent, MemberName name, Attributes attrs, MemberKind kind)
: base (parent, name, attrs)
{
this.Kind = kind;
defined_names = new Dictionary<string, MemberCore> ();
}
TypeContainer pop_current_class ()
{
var retval = current_container;
current_container = current_container.Parent;
current_type = current_type.Parent as TypeDefinition;
return retval;
}
protected override void AddTypeContainerMember (TypeContainer tc)
{
members.Add (tc);
if (containers == null)
containers = new List<TypeContainer> ();
base.AddTypeContainerMember (tc);
}
public override void Define (TypeContainer parent)
{
parameters.Resolve (this);
base.Define (parent);
Spec = new MethodSpec (MemberKind.Method, parent.PartialContainer.Definition, this, ReturnType, ParameterInfo, ModFlags);
method_data = new MethodData (method, ModFlags, flags, this);
method_data.Define (parent.PartialContainer, method.GetFullName (MemberName));
}