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)); }