public MemberName (MemberName left, MemberName right) { this.Name = right.Name; this.Location = right.Location; this.TypeArguments = right.TypeArguments; this.Left = left; }
public MemberName (MemberName left, MemberName right) { this.Name = right.Name; this.Location = right.Location; this.TypeParameters = right.TypeParameters; this.Left = left; }
public MethodCore (DeclSpace parent, GenericMethod generic, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, MemberName name, Attributes attrs, ParametersCompiled parameters) : base (parent, generic, type, mod, allowed_mod, name, attrs) { this.parameters = parameters; }
public Class(TypeContainer parent, MemberName name, Modifiers mod, Attributes attrs) : base(parent, name, attrs, MemberKind.Class) { var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE; this.ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod, accmods, Location, Report); spec = new TypeSpec (Kind, null, this, null, ModFlags); }
public HoistedStoreyClass (TypeContainer parent, MemberName name, TypeParameter[] tparams, Modifiers mod) : base (parent, name, mod | Modifiers.PRIVATE) { if (tparams != null) { type_params = new TypeParameter[tparams.Length]; var src = new TypeParameterSpec[tparams.Length]; var dst = new TypeParameterSpec[tparams.Length]; for (int i = 0; i < type_params.Length; ++i) { type_params[i] = tparams[i].CreateHoistedCopy (this, spec); src[i] = tparams[i].Type; dst[i] = type_params[i].Type; } // A copy is not enough, inflate any type parameter constraints // using a new type parameters var inflator = new TypeParameterInflator (this, null, src, dst); for (int i = 0; i < type_params.Length; ++i) { src[i].InflateConstraints (inflator, dst[i]); } mutator = new TypeParameterMutator (tparams, type_params); } }
private MemberName (MemberName left, string name, bool is_double_colon, TypeArguments args, Location loc) : this (left, name, is_double_colon, loc) { if (args != null && args.Count > 0) this.TypeArguments = args; }
protected Event(DeclSpace parent, FullNamedExpression type, Modifiers mod_flags, MemberName name, Attributes attrs) : base(parent, null, type, mod_flags, parent.PartialContainer.Kind == MemberKind.Interface ? AllowedModifiersInterface : parent.PartialContainer.Kind == MemberKind.Struct ? AllowedModifiersStruct : AllowedModifiersClass, name, attrs) { }
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); }
protected FieldBase (DeclSpace parent, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, MemberName name, Attributes attrs) : base (parent, null, type, mod, allowed_mod | Modifiers.ABSTRACT, Modifiers.PRIVATE, name, attrs) { if ((mod & Modifiers.ABSTRACT) != 0) Report.Error (681, Location, "The modifier 'abstract' is not valid on fields. Try using a property instead"); }
private MemberName (MemberName left, string name, bool is_double_colon, Location loc) { this.Name = name; this.Location = loc; this.is_double_colon = is_double_colon; this.Left = left; }
public Class(NamespaceEntry ns, DeclSpace parent, MemberName name, Modifiers mod, Attributes attrs) : base(ns, parent, name, attrs, MemberKind.Class) { var accmods = (Parent == null || Parent.Parent == null) ? Modifiers.INTERNAL : Modifiers.PRIVATE; this.ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod, accmods, Location, Report); spec = new TypeSpec (Kind, null, this, null, ModFlags); }
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 Enum(NamespaceEntry ns, DeclSpace parent, TypeExpr type, Modifiers mod_flags, MemberName name, Attributes attrs) : base(ns, parent, name, attrs, MemberKind.Enum) { this.base_type = 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 TypeContainer (TypeContainer parent, MemberName name, Attributes attrs, MemberKind kind) : base (parent, name, attrs) { this.Kind = kind; if (name != null) this.Basename = name.Basename; defined_names = new Dictionary<string, MemberCore> (); }
public HoistedStoreyClass (DeclSpace parent, MemberName name, TypeParameter[] tparams, Modifiers mod) : base (parent, name, mod | Modifiers.PRIVATE) { if (tparams != null) { type_params = new TypeParameter[tparams.Length]; for (int i = 0; i < type_params.Length; ++i) { type_params[i] = tparams[i].CreateHoistedCopy (this, spec); } } }
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 Delegate (NamespaceEntry ns, DeclSpace parent, FullNamedExpression type, int mod_flags, MemberName name, ParametersCompiled param_list, Attributes attrs) : base (ns, parent, name, attrs, Kind.Delegate) { this.ReturnType = type; ModFlags = Modifiers.Check (AllowedModifiers, mod_flags, IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE, name.Location, Report); Parameters = param_list; }
public Class(NamespaceEntry ns, DeclSpace parent, MemberName name, Modifiers mod, Attributes attrs) : base(ns, parent, name, attrs, MemberKind.Class) { var accmods = (Parent == null || Parent.Parent == null) ? Modifiers.INTERNAL : Modifiers.PRIVATE; this.ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod, accmods, Location, Report); spec = new TypeSpec (Kind, null, this, null, ModFlags); if (IsStatic && RootContext.Version == LanguageVersion.ISO_1) { Report.FeatureIsNotAvailable (Location, "static classes"); } }
protected CompilerGeneratedClass (DeclSpace parent, GenericMethod generic, MemberName name, int mod) : this (parent, name, mod) { if (generic != null) { ArrayList list = new ArrayList (); foreach (TypeParameter tparam in generic.TypeParameters) { if (tparam.Constraints != null) list.Add (tparam.Constraints.Clone ()); } SetParameterInfo (list); } }
AstType ConvertToType (MemberName memberName) { AstType result; if (memberName.Left != null) { result = new MemberType () { MemberName = memberName.Name }; result.AddChild (ConvertToType (memberName.Left), MemberType.TargetRole); } else { result = new SimpleType () { Identifier = memberName.Name }; } if (memberName.TypeArguments != null && !memberName.TypeArguments.IsEmpty) { foreach (var arg in memberName.TypeArguments.Args) { result.AddChild (ConvertToType (arg), AstType.Roles.TypeArgument); } } return result; }
/// <remarks> /// If a method in Type `t' (or null to look in all interfaces /// and the base abstract class) with name `Name', return type `ret_type' and /// arguments `args' implements an interface, this method will /// return the MethodInfo that this method implements. /// /// If `name' is null, we operate solely on the method's signature. This is for /// instance used when implementing indexers. /// /// The `Operation op' controls whether to lookup, clear the pending bit, or clear /// all the methods with the given signature. /// /// The `MethodInfo need_proxy' is used when we're implementing an interface's /// indexer in a class. If the new indexer's IndexerName does not match the one /// that was used in the interface, then we always need to create a proxy for it. /// /// </remarks> public MethodSpec InterfaceMethod(MemberName name, TypeSpec iType, MethodData method, Operation op, out MethodSpec ambiguousCandidate, ref bool optional) { ambiguousCandidate = null; if (pending_implementations == null) { return(null); } TypeSpec ret_type = method.method.ReturnType; ParametersCompiled args = method.method.ParameterInfo; bool is_indexer = method.method is Indexer.SetIndexerMethod || method.method is Indexer.GetIndexerMethod; MethodSpec m; foreach (TypeAndMethods tm in pending_implementations) { if (!(iType == null || tm.type == iType)) { continue; } int method_count = tm.methods.Count; for (int i = 0; i < method_count; i++) { m = tm.methods [i]; if (m == null) { continue; } if (is_indexer) { if (!m.IsAccessor || m.Parameters.IsEmpty) { continue; } } else { if (name.Name != m.Name) { continue; } if (m.Arity != name.Arity) { continue; } } if (!TypeSpecComparer.Override.IsEqual(m.Parameters, args)) { continue; } if (!TypeSpecComparer.Override.IsEqual(m.ReturnType, ret_type)) { tm.found[i] = method; continue; } // // `need_proxy' is not null when we're implementing an // interface indexer and this is Clear(One/All) operation. // // If `name' is null, then we do a match solely based on the // signature and not on the name (this is done in the Lookup // for an interface indexer). // if (op != Operation.Lookup) { if (m.IsAccessor != method.method.IsAccessor) { continue; } // If `t != null', then this is an explicitly interface // implementation and we can always clear the method. // `need_proxy' is not null if we're implementing an // interface indexer. In this case, we need to create // a proxy if the implementation's IndexerName doesn't // match the IndexerName in the interface. if (m.DeclaringType.IsInterface && iType == null && name.Name != m.Name) // TODO: This is very expensive comparison { tm.need_proxy[i] = method.method.Spec; } else { tm.methods[i] = null; } } else { tm.found [i] = method; optional = tm.optional; } if (op == Operation.Lookup && name.ExplicitInterface != null && ambiguousCandidate == null) { ambiguousCandidate = m; continue; } // // Lookups and ClearOne return // if (op != Operation.ClearAll) { return(m); } } // If a specific type was requested, we can stop now. if (tm.type == iType) { break; } } m = ambiguousCandidate; ambiguousCandidate = null; return(m); }
public HoistedStoreyClass (TypeDefinition parent, MemberName name, TypeParameters tparams, Modifiers mods, MemberKind kind) : base (parent, name, mods | Modifiers.PRIVATE, kind) { if (tparams != null) { var type_params = name.TypeParameters; var src = new TypeParameterSpec[tparams.Count]; var dst = new TypeParameterSpec[tparams.Count]; for (int i = 0; i < tparams.Count; ++i) { type_params[i] = tparams[i].CreateHoistedCopy (spec); src[i] = tparams[i].Type; dst[i] = type_params[i].Type; } // A copy is not enough, inflate any type parameter constraints // using a new type parameters var inflator = new TypeParameterInflator (this, null, src, dst); for (int i = 0; i < tparams.Count; ++i) { src[i].InflateConstraints (inflator, dst[i]); } mutator = new TypeParameterMutator (tparams, type_params); } }
public GetEnumeratorMethod(IteratorStorey host, FullNamedExpression returnType, MemberName name) : base(host, null, returnType, Modifiers.DEBUGGER_HIDDEN, name) { Block.AddStatement(new GetEnumeratorStatement(host, this)); }
public Using(Location usingLocation, MemberName nSpace, Location semicolonLocation) { this.UsingLocation = usingLocation; this.NSpace = nSpace; this.SemicolonLocation = semicolonLocation; }
public void DefineIteratorMembers() { pc_field = AddCompilerGeneratedField("$PC", TypeManager.system_int32_expr); current_field = AddCompilerGeneratedField("$current", iterator_type_expr); if (hoisted_params != null) { // // Iterators are independent, each GetEnumerator call has to // create same enumerator therefore we have to keep original values // around for re-initialization // // TODO: Do it for assigned/modified parameters only // hoisted_params_copy = new ArrayList(hoisted_params.Count); foreach (HoistedParameter hp in hoisted_params) { hoisted_params_copy.Add(new HoistedParameter(hp, "<$>" + hp.Field.Name)); } } if (generic_enumerator_type != null) { Define_Current(true); } Define_Current(false); new DisposeMethod(this); Define_Reset(); if (Iterator.IsEnumerable) { MemberName name = new MemberName(QualifiedAliasMember.GlobalAlias, "System", null, Location); name = new MemberName(name, "Collections", Location); name = new MemberName(name, "IEnumerable", Location); name = new MemberName(name, "GetEnumerator", Location); if (generic_enumerator_type != null) { Method get_enumerator = new IteratorMethod(this, enumerator_type, 0, name); name = new MemberName(name.Left.Left, "Generic", Location); name = new MemberName(name, "IEnumerable", generic_args, Location); name = new MemberName(name, "GetEnumerator", Location); Method gget_enumerator = new GetEnumeratorMethod(this, generic_enumerator_type, name); // // Just call generic GetEnumerator implementation // get_enumerator.Block.AddStatement( new Return(new Invocation(new DynamicMethodGroupExpr(gget_enumerator, Location), null), Location)); AddMethod(get_enumerator); AddMethod(gget_enumerator); } else { AddMethod(new GetEnumeratorMethod(this, enumerator_type, name)); } } }
public IteratorMethod(IteratorStorey host, FullNamedExpression returnType, int mod, MemberName name) : base(host, null, returnType, mod | Modifiers.DEBUGGER_HIDDEN | Modifiers.COMPILER_GENERATED, name, ParametersCompiled.EmptyReadOnlyParameters, null) { this.host = host; Block = new ToplevelBlock(Compiler, host.Iterator.Container.Toplevel, ParametersCompiled.EmptyReadOnlyParameters, Location); }
protected virtual void SetMemberName(MemberName new_name) { member_name = new_name; }
public MemberName(MemberName left, string name, FullNamedExpression explicitInterface, Location loc) : this(left, name, loc) { this.ExplicitInterface = explicitInterface; }
public static GetEnumeratorMethod Create(IteratorStorey host, FullNamedExpression returnType, MemberName name) { return(Create(host, returnType, name, null)); }
public static GetEnumeratorMethod Create(IteratorStorey host, FullNamedExpression returnType, MemberName name, Statement statement) { var m = new GetEnumeratorMethod(host, returnType, name); var stmt = statement ?? new GetEnumeratorStatement(host, m); m.block.AddStatement(stmt); return(m); }
GetEnumeratorMethod(IteratorStorey host, FullNamedExpression returnType, MemberName name) : base(host, null, returnType, Modifiers.DEBUGGER_HIDDEN, name, ToplevelBlock.Flags.CompilerGenerated | ToplevelBlock.Flags.NoFlowAnalysis) { }
public void AddUsing(Location usingLocation, MemberName nspace, Location semicolonLocation) { curNamespace.Peek().usings.Add(new Using(usingLocation, nspace, semicolonLocation)); }
public void AddUsingAlias(Location usingLocation, Tokenizer.LocatedToken identifier, Location assignLocation, MemberName nspace, Location semicolonLocation) { curNamespace.Peek().usings.Add(new AliasUsing(usingLocation, identifier, assignLocation, nspace, semicolonLocation)); }
// // Creates a host for the anonymous method // AnonymousMethodMethod DoCreateMethodHost (EmitContext ec) { // // Anonymous method body can be converted to // // 1, an instance method in current scope when only `this' is hoisted // 2, a static method in current scope when neither `this' nor any variable is hoisted // 3, an instance method in compiler generated storey when any hoisted variable exists // Modifiers modifiers; TypeDefinition parent = null; var src_block = Block.Original.Explicit; if (src_block.HasCapturedVariable || src_block.HasCapturedThis) { parent = storey = FindBestMethodStorey (); if (storey == null) { var sm = src_block.ParametersBlock.TopBlock.StateMachine; // // Remove hoisted this demand when simple instance method is enough (no hoisted variables only this) // if (src_block.HasCapturedThis && src_block.ParametersBlock.StateMachine == null) { src_block.ParametersBlock.TopBlock.RemoveThisReferenceFromChildrenBlock (src_block); // // Special case where parent class is used to emit instance method // because currect storey is of value type (async host) and we don't // want to create another childer storey to host this reference only // if (sm != null && sm.Kind == MemberKind.Struct) parent = sm.Parent.PartialContainer; } // // For iterators we can host everything in one class // if (sm is IteratorStorey) parent = storey = sm; } modifiers = storey != null ? Modifiers.INTERNAL : Modifiers.PRIVATE; } else { if (ec.CurrentAnonymousMethod != null) parent = storey = ec.CurrentAnonymousMethod.Storey; modifiers = Modifiers.STATIC | Modifiers.PRIVATE; } if (parent == null) parent = ec.CurrentTypeDefinition.Parent.PartialContainer; string name = CompilerGeneratedContainer.MakeName (parent != storey ? block_name : null, "m", null, ec.Module.CounterAnonymousMethods++); MemberName member_name; if (storey == null && ec.CurrentTypeParameters != null) { var hoisted_tparams = ec.CurrentTypeParameters; var type_params = new TypeParameters (hoisted_tparams.Count); for (int i = 0; i < hoisted_tparams.Count; ++i) { type_params.Add (hoisted_tparams[i].CreateHoistedCopy (null)); } member_name = new MemberName (name, type_params, Location); } else { member_name = new MemberName (name, Location); } return new AnonymousMethodMethod (parent, this, storey, new TypeExpression (ReturnType, Location), modifiers, member_name, parameters); }
public void ImplementMethod(MemberName name, TypeSpec ifaceType, MethodData method, bool clear_one, out MethodSpec ambiguousCandidate, ref bool optional) { InterfaceMethod(name, ifaceType, method, clear_one ? Operation.ClearOne : Operation.ClearAll, out ambiguousCandidate, ref optional); }
protected CompilerGeneratedContainer (TypeContainer parent, MemberName name, Modifiers mod) : this (parent, name, mod, MemberKind.Class) { }
protected FieldBase(TypeDefinition parent, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, MemberName name, Attributes attrs) : base(parent, type, mod, allowed_mod | Modifiers.ABSTRACT, Modifiers.PRIVATE, name, attrs) { if ((mod & Modifiers.ABSTRACT) != 0) { Report.Error(681, Location, "The modifier 'abstract' is not valid on fields. Try using a property instead"); } }
GetEnumeratorMethod(IteratorStorey host, FullNamedExpression returnType, MemberName name) : base(host, null, returnType, Modifiers.DEBUGGER_HIDDEN, name) { }
public DocumentationMemberContext(MemberCore host, MemberName contextName) { this.host = host; this.contextName = contextName; }
public GetEnumeratorMethod(IteratorStorey host, FullNamedExpression returnType, MemberName name) : base(host, returnType, 0, name) { Block.AddStatement(new GetEnumeratorStatement(host, this)); }
public ClassOrStruct (TypeContainer parent, MemberName name, Attributes attrs, MemberKind kind) : base (parent, name, attrs, kind) { }
protected override bool DoDefineMembers() { current_field = AddCompilerGeneratedField("$current", iterator_type_expr); disposing_field = AddCompilerGeneratedField("$disposing", new TypeExpression(Compiler.BuiltinTypes.Bool, Location)); if (Iterator.IsEnumerable && hoisted_params != null) { // // Iterators are independent, each GetEnumerator call has to // create same enumerator therefore we have to keep original values // around for re-initialization // hoisted_params_copy = new List <HoistedParameter> (hoisted_params.Count); foreach (HoistedParameter hp in hoisted_params) { // // Don't create field copy for unmodified captured parameters // HoistedParameter hp_copy; if (hp.IsAssigned) { hp_copy = new HoistedParameter(hp, "<$>" + hp.Field.Name); } else { hp_copy = null; } hoisted_params_copy.Add(hp_copy); } } if (generic_enumerator_type != null) { Define_Current(true); } Define_Current(false); new DisposeMethod(this); Define_Reset(); if (Iterator.IsEnumerable) { FullNamedExpression explicit_iface = new TypeExpression(Compiler.BuiltinTypes.IEnumerable, Location); var name = new MemberName("GetEnumerator", null, explicit_iface, Location.Null); if (generic_enumerator_type != null) { explicit_iface = new TypeExpression(generic_enumerable_type, Location); var gname = new MemberName("GetEnumerator", null, explicit_iface, Location.Null); Method gget_enumerator = GetEnumeratorMethod.Create(this, new TypeExpression(generic_enumerator_type, Location), gname); // // Just call generic GetEnumerator implementation // var stmt = new Return(new Invocation(new DynamicMethodGroupExpr(gget_enumerator, Location), null), Location); Method get_enumerator = GetEnumeratorMethod.Create(this, new TypeExpression(Compiler.BuiltinTypes.IEnumerator, Location), name, stmt); Members.Add(get_enumerator); Members.Add(gget_enumerator); } else { Members.Add(GetEnumeratorMethod.Create(this, new TypeExpression(Compiler.BuiltinTypes.IEnumerator, Location), name)); } } return(base.DoDefineMembers()); }
// // Returns full metadata method name // public string GetFullName (MemberName name) { return GetFullName (name.Name); }
public EnumMember(Enum parent, MemberName name, Attributes attrs) : base(parent, new EnumTypeExpr(), Modifiers.PUBLIC, name, attrs) { }
public AliasUsing(Location usingLocation, Tokenizer.LocatedToken identifier, Location assignLocation, MemberName nspace, Location semicolonLocation) { this.UsingLocation = usingLocation; this.Identifier = identifier; this.AssignLocation = assignLocation; this.Nspace = nspace; this.SemicolonLocation = semicolonLocation; }
public InterfaceMemberBase (TypeDefinition parent, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, MemberName name, Attributes attrs) : base (parent, type, mod, allowed_mod, Modifiers.PRIVATE, name, attrs) { IsInterface = parent.Kind == MemberKind.Interface; IsExplicitImpl = (MemberName.ExplicitInterface != null); explicit_mod_flags = mod; }
public Field(TypeDefinition parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs) : base(parent, type, mod, AllowedModifiers, name, attrs) { }
protected MemberBase (TypeDefinition parent, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, Modifiers def_mod, MemberName name, Attributes attrs) : base (parent, name, attrs) { this.Parent = parent; this.type_expr = type; if (name != MemberName.Null) ModFlags = ModifiersExtensions.Check (allowed_mod, mod, def_mod, Location, Report); }
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 TypeDefinition (TypeContainer parent, MemberName name, Attributes attrs, MemberKind kind) : base (parent, name, attrs, kind) { PartialContainer = this; members = new List<MemberCore> (); }
public Field(DeclSpace parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs) : base(parent, type, mod ^ Modifiers.ROLE, AllowedModifiers, name, attrs) { isRole = (mod & Modifiers.ROLE) == Modifiers.ROLE; }
public AnonymousMethodMethod (TypeDefinition parent, AnonymousExpression am, AnonymousMethodStorey storey, TypeExpr return_type, Modifiers mod, MemberName name, ParametersCompiled parameters) : base (parent, return_type, mod | Modifiers.COMPILER_GENERATED, name, parameters, null) { this.AnonymousMethod = am; this.Storey = storey; Parent.PartialContainer.Members.Add (this); Block = new ToplevelBlock (am.block, parameters); }
public RoleField(DeclSpace parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs) : base(parent, type, mod, name, attrs) { }
private AnonymousTypeClass (ModuleContainer parent, MemberName name, IList<AnonymousTypeParameter> parameters, Location loc) : base (parent, name, parent.Evaluator != null ? Modifiers.PUBLIC : Modifiers.INTERNAL) { this.parameters = parameters; }
public StateMachineMethod(StateMachine host, StateMachineInitializer expr, FullNamedExpression returnType, Modifiers mod, MemberName name) : base(host, returnType, mod | Modifiers.COMPILER_GENERATED, name, ParametersCompiled.EmptyReadOnlyParameters, null) { this.expr = expr; Block = new ToplevelBlock(host.Compiler, ParametersCompiled.EmptyReadOnlyParameters, Location.Null); }
/// <summary> /// Whether the specified method is an interface method implementation /// </summary> public MethodSpec IsInterfaceMethod(MemberName name, TypeSpec ifaceType, MethodData method, out MethodSpec ambiguousCandidate, ref bool optional) { return(InterfaceMethod(name, ifaceType, method, Operation.Lookup, out ambiguousCandidate, ref optional)); }
public MemberName(MemberName left, string name, Location loc) { this.Name = name; this.Location = loc; this.Left = left; }