protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class) { base_type = Compiler.BuiltinTypes.Object; base_class = null; return null; }
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 static ParametersCompiled CreateImplicitParameter (FullNamedExpression texpr, Location loc) { return new ParametersCompiled ( new[] { new Parameter (texpr, "value", Parameter.Modifier.NONE, null, loc) }, null); }
public Parameter (FullNamedExpression type, string name, Modifier mod, Attributes attrs, Location loc) { this.name = name; modFlags = mod; this.loc = loc; texpr = type; // Only assign, attributes will be attached during resolve base.attributes = attrs; }
public FullNamedExpression(Statement statement, FullNamedExpression left, SourceData sourceData) : base(statement, sourceData) { Left = left; }
public OperatorDeclaration (Operator.OpType op, FullNamedExpression ret_type, Location location) { optype = op; this.ret_type = ret_type; this.location = location; }
protected MethodOrOperator (TypeDefinition parent, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, MemberName name, Attributes attrs, ParametersCompiled parameters) : base (parent, type, mod, allowed_mod, name, attrs, parameters) { }
protected Method (TypeDefinition parent, FullNamedExpression return_type, Modifiers mod, Modifiers amod, MemberName name, ParametersCompiled parameters, Attributes attrs) : base (parent, return_type, mod, amod, name, attrs, parameters) { }
public MemberName(MemberName left, string name, FullNamedExpression explicitInterface, Location loc) : this(left, name, loc) { this.ExplicitInterface = explicitInterface; }
GetEnumeratorMethod(IteratorStorey host, FullNamedExpression returnType, MemberName name) : base(host, null, returnType, Modifiers.DEBUGGER_HIDDEN, name, ToplevelBlock.Flags.CompilerGenerated | ToplevelBlock.Flags.NoFlowAnalysis) { }
public DocumentationParameter(Parameter.Modifier modifier, FullNamedExpression type) : this(type) { this.Modifier = modifier; }
public DocumentationParameter(FullNamedExpression type) { this.Type = type; }
// // Processes "see" or "seealso" elements from cref attribute. // void HandleXrefCommon(MemberCore mc, TypeContainer ds, XmlElement xref) { string cref = xref.GetAttribute("cref"); // when, XmlReader, "if (cref == null)" if (!xref.HasAttribute("cref")) { return; } // Nothing to be resolved the reference is marked explicitly if (cref.Length > 2 && cref [1] == ':') { return; } // Additional symbols for < and > are allowed for easier XML typing cref = cref.Replace('{', '<').Replace('}', '>'); var encoding = module.Compiler.Settings.Encoding; var s = new MemoryStream(encoding.GetBytes(cref)); var source_file = new CompilationSourceFile(doc_module, mc.Location.SourceFile); var report = new Report(doc_module.Compiler, new NullReportPrinter()); if (session == null) { session = new ParserSession() { UseJayGlobalArrays = true } } ; SeekableStreamReader seekable = new SeekableStreamReader(s, encoding, session.StreamReaderBuffer); var parser = new CSharpParser(seekable, source_file, report, session); ParsedParameters = null; ParsedName = null; ParsedBuiltinType = null; ParsedOperator = null; parser.Lexer.putback_char = Tokenizer.DocumentationXref; parser.Lexer.parsing_generic_declaration_doc = true; parser.parse(); if (report.Errors > 0) { Report.Warning(1584, 1, mc.Location, "XML comment on `{0}' has syntactically incorrect cref attribute `{1}'", mc.GetSignatureForError(), cref); xref.SetAttribute("cref", "!:" + cref); return; } MemberSpec member; string prefix = null; FullNamedExpression fne = null; // // Try built-in type first because we are using ParsedName as identifier of // member names on built-in types // if (ParsedBuiltinType != null && (ParsedParameters == null || ParsedName != null)) { member = ParsedBuiltinType.Type; } else { member = null; } if (ParsedName != null || ParsedOperator.HasValue) { TypeSpec type = null; string member_name = null; if (member == null) { if (ParsedOperator.HasValue) { type = mc.CurrentType; } else if (ParsedName.Left != null) { fne = ResolveMemberName(mc, ParsedName.Left); if (fne != null) { var ns = fne as Namespace; if (ns != null) { fne = ns.LookupTypeOrNamespace(mc, ParsedName.Name, ParsedName.Arity, LookupMode.Probing, Location.Null); if (fne != null) { member = fne.Type; } } else { type = fne.Type; } } } else { fne = ResolveMemberName(mc, ParsedName); if (fne == null) { type = mc.CurrentType; } else if (ParsedParameters == null) { member = fne.Type; } else if (fne.Type.MemberDefinition == mc.CurrentType.MemberDefinition) { member_name = Constructor.ConstructorName; type = fne.Type; } } } else { type = (TypeSpec)member; member = null; } if (ParsedParameters != null) { var old_printer = mc.Module.Compiler.Report.SetPrinter(new NullReportPrinter()); try { var context = new DocumentationMemberContext(mc, ParsedName ?? MemberName.Null); foreach (var pp in ParsedParameters) { pp.Resolve(context); } } finally { mc.Module.Compiler.Report.SetPrinter(old_printer); } } if (type != null) { if (member_name == null) { member_name = ParsedOperator.HasValue ? Operator.GetMetadataName(ParsedOperator.Value) : ParsedName.Name; } int parsed_param_count; if (ParsedOperator == Operator.OpType.Explicit || ParsedOperator == Operator.OpType.Implicit) { parsed_param_count = ParsedParameters.Count - 1; } else if (ParsedParameters != null) { parsed_param_count = ParsedParameters.Count; } else { parsed_param_count = 0; } int parameters_match = -1; do { var members = MemberCache.FindMembers(type, member_name, true); if (members != null) { foreach (var m in members) { if (ParsedName != null && m.Arity != ParsedName.Arity) { continue; } if (ParsedParameters != null) { IParametersMember pm = m as IParametersMember; if (pm == null) { continue; } if (m.Kind == MemberKind.Operator && !ParsedOperator.HasValue) { continue; } var pm_params = pm.Parameters; int i; for (i = 0; i < parsed_param_count; ++i) { var pparam = ParsedParameters[i]; if (i >= pm_params.Count || pparam == null || pparam.TypeSpec == null || !TypeSpecComparer.Override.IsEqual(pparam.TypeSpec, pm_params.Types[i]) || (pparam.Modifier & Parameter.Modifier.RefOutMask) != (pm_params.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask)) { if (i > parameters_match) { parameters_match = i; } i = -1; break; } } if (i < 0) { continue; } if (ParsedOperator == Operator.OpType.Explicit || ParsedOperator == Operator.OpType.Implicit) { if (pm.MemberType != ParsedParameters[parsed_param_count].TypeSpec) { parameters_match = parsed_param_count + 1; continue; } } else { if (parsed_param_count != pm_params.Count) { continue; } } } if (member != null) { Report.Warning(419, 3, mc.Location, "Ambiguous reference in cref attribute `{0}'. Assuming `{1}' but other overloads including `{2}' have also matched", cref, member.GetSignatureForError(), m.GetSignatureForError()); break; } member = m; } } // Continue with parent type for nested types if (member == null) { type = type.DeclaringType; } else { type = null; } } while (type != null); if (member == null && parameters_match >= 0) { for (int i = parameters_match; i < parsed_param_count; ++i) { Report.Warning(1580, 1, mc.Location, "Invalid type for parameter `{0}' in XML comment cref attribute `{1}'", (i + 1).ToString(), cref); } if (parameters_match == parsed_param_count + 1) { Report.Warning(1581, 1, mc.Location, "Invalid return type in XML comment cref attribute `{0}'", cref); } } } } if (member == null) { Report.Warning(1574, 1, mc.Location, "XML comment on `{0}' has cref attribute `{1}' that could not be resolved", mc.GetSignatureForError(), cref); cref = "!:" + cref; } else if (member == InternalType.Namespace) { cref = "N:" + fne.GetSignatureForError(); } else { prefix = GetMemberDocHead(member); cref = prefix + member.GetSignatureForDocumentation(); } xref.SetAttribute("cref", cref); }
protected override TypeSpec[] ResolveBaseTypes(out FullNamedExpression base_class) { base_type = Compiler.BuiltinTypes.MulticastDelegate; base_class = null; return(null); }
public static GetEnumeratorMethod Create(IteratorStorey host, FullNamedExpression returnType, MemberName name) { return(Create(host, returnType, name, null)); }
protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class) { var ifaces = base.ResolveBaseTypes (out base_class); if (base_class == null) { if (spec.BuiltinType != BuiltinTypeSpec.Type.Object) base_type = Compiler.BuiltinTypes.Object; } else { if (base_type.IsGenericParameter){ Report.Error (689, base_class.Location, "`{0}': Cannot derive from type parameter `{1}'", GetSignatureForError (), base_type.GetSignatureForError ()); } else if (base_type.IsStatic) { Report.SymbolRelatedToPreviousError (base_type); Report.Error (709, Location, "`{0}': Cannot derive from static class `{1}'", GetSignatureForError (), base_type.GetSignatureForError ()); } else if (base_type.IsSealed) { Report.SymbolRelatedToPreviousError (base_type); Report.Error (509, Location, "`{0}': cannot derive from sealed type `{1}'", GetSignatureForError (), base_type.GetSignatureForError ()); } else if (PartialContainer.IsStatic && base_type.BuiltinType != BuiltinTypeSpec.Type.Object) { Report.Error (713, Location, "Static class `{0}' cannot derive from type `{1}'. Static classes must derive from object", GetSignatureForError (), base_type.GetSignatureForError ()); } switch (base_type.BuiltinType) { case BuiltinTypeSpec.Type.Enum: case BuiltinTypeSpec.Type.ValueType: case BuiltinTypeSpec.Type.MulticastDelegate: case BuiltinTypeSpec.Type.Delegate: case BuiltinTypeSpec.Type.Array: if (!(spec is BuiltinTypeSpec)) { Report.Error (644, Location, "`{0}' cannot derive from special class `{1}'", GetSignatureForError (), base_type.GetSignatureForError ()); base_type = Compiler.BuiltinTypes.Object; } break; } if (!IsAccessibleAs (base_type)) { Report.SymbolRelatedToPreviousError (base_type); Report.Error (60, Location, "Inconsistent accessibility: base class `{0}' is less accessible than class `{1}'", base_type.GetSignatureForError (), GetSignatureForError ()); } } if (PartialContainer.IsStatic && ifaces != null) { foreach (var t in ifaces) Report.SymbolRelatedToPreviousError (t); Report.Error (714, Location, "Static class `{0}' cannot implement interfaces", GetSignatureForError ()); } return ifaces; }
public Expression GetInitializer (FullNamedExpression type) { if (initializer is ArrayInitializer) return new ArrayCreation (type, "", (ArrayInitializer)initializer, MemberName.Location); return initializer; }
protected 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) { }
public VariableAccess(Statement statement, FullNamedExpression member, SourceData sourceData) : base(statement, sourceData) { Member = member; }
public Property (TypeDefinition parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs) : base (parent, type, mod, parent.PartialContainer.Kind == MemberKind.Interface ? AllowedModifiersInterface : parent.PartialContainer.Kind == MemberKind.Struct ? AllowedModifiersStruct : AllowedModifiersClass, name, attrs) { }
public Operator (TypeDefinition parent, OpType type, FullNamedExpression ret_type, Modifiers mod_flags, ParametersCompiled parameters, ToplevelBlock block, Attributes attrs, Location loc) : base (parent, ret_type, mod_flags, AllowedModifiers, new MemberName (GetMetadataName (type), loc), attrs, parameters) { OperatorType = type; Block = block; }
public EventProperty (TypeDefinition parent, FullNamedExpression type, Modifiers mod_flags, MemberName name, Attributes attrs) : base (parent, type, mod_flags, name, attrs) { }
public Method (TypeDefinition parent, FullNamedExpression return_type, Modifiers mod, MemberName name, ParametersCompiled parameters, Attributes attrs) : base (parent, return_type, mod, parent.PartialContainer.Kind == MemberKind.Interface ? AllowedModifiersInterface : parent.PartialContainer.Kind == MemberKind.Struct ? AllowedModifiersStruct | Modifiers.ASYNC : AllowedModifiersClass | Modifiers.ASYNC, name, attrs, parameters) { }
public MemberName (string name, TypeParameters tparams, FullNamedExpression explicitInterface, Location loc) : this (name, tparams, loc) { this.ExplicitInterface = explicitInterface; }
public static Method Create (TypeDefinition parent, FullNamedExpression returnType, Modifiers mod, MemberName name, ParametersCompiled parameters, Attributes attrs) { var m = new Method (parent, returnType, mod, name, parameters, attrs); if ((mod & Modifiers.PARTIAL) != 0) { const Modifiers invalid_partial_mod = Modifiers.AccessibilityMask | Modifiers.ABSTRACT | Modifiers.EXTERN | Modifiers.NEW | Modifiers.OVERRIDE | Modifiers.SEALED | Modifiers.VIRTUAL; if ((mod & invalid_partial_mod) != 0) { m.Report.Error (750, m.Location, "A partial method cannot define access modifier or any of abstract, extern, new, override, sealed, or virtual modifiers"); mod &= ~invalid_partial_mod; } if ((parent.ModFlags & Modifiers.PARTIAL) == 0) { m.Report.Error (751, m.Location, "A partial method must be declared within a partial class or partial struct"); } } if ((mod & Modifiers.STATIC) == 0 && parameters.HasExtensionMethodType) { m.Report.Error (1105, m.Location, "`{0}': Extension methods must be declared static", m.GetSignatureForError ()); } return m; }
public MemberName (MemberName left, string name, FullNamedExpression explicitInterface, Location loc) : this (left, name, loc) { this.ExplicitInterface = explicitInterface; }
public SimpleName(Statement statement, FullNamedExpression left, string value, SourceData sourceData) : base(statement, left, sourceData) { Value = value; }
public Const (TypeDefinition parent, FullNamedExpression type, Modifiers mod_flags, MemberName name, Attributes attrs) : base (parent, type, mod_flags, AllowedModifiers, name, attrs) { ModFlags |= Modifiers.STATIC; }
public FieldSpec CreateCallSiteField (FullNamedExpression type, Location loc) { int index = AnonymousMethodsCounter++; Field f = new HoistedField (this, type, Modifiers.PUBLIC | Modifiers.STATIC, "Site" + index.ToString ("X"), null, loc); f.Define (); AddField (f); return f.Spec; }
public virtual void Define (NamespaceContainer ctx) { resolved = expr.ResolveAsTypeOrNamespace (ctx, false); }
public ParamsParameter (FullNamedExpression type, string name, Attributes attrs, Location loc): base (type, name, Parameter.Modifier.PARAMS, attrs, loc) { }
public Field (TypeDefinition parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs) : base (parent, type, mod, AllowedModifiers, name, attrs) { }
/// <summary> /// This function computes the Base class and also the /// list of interfaces that the class or struct @c implements. /// /// The return value is an array (might be null) of /// interfaces implemented (as Types). /// /// The @base_class argument is set to the base object or null /// if this is `System.Object'. /// </summary> protected virtual TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class) { base_class = null; if (type_bases == null) return null; int count = type_bases.Count; TypeSpec[] ifaces = null; var base_context = new BaseContext (this); for (int i = 0, j = 0; i < count; i++){ FullNamedExpression fne = type_bases [i]; var fne_resolved = fne.ResolveAsType (base_context); if (fne_resolved == null) continue; if (i == 0 && Kind == MemberKind.Class && !fne_resolved.IsInterface) { if (fne_resolved.BuiltinType == BuiltinTypeSpec.Type.Dynamic) { Report.Error (1965, Location, "Class `{0}' cannot derive from the dynamic type", GetSignatureForError ()); continue; } base_type = fne_resolved; base_class = fne; continue; } if (ifaces == null) ifaces = new TypeSpec [count - i]; if (fne_resolved.IsInterface) { for (int ii = 0; ii < j; ++ii) { if (fne_resolved == ifaces [ii]) { Report.Error (528, Location, "`{0}' is already listed in interface list", fne_resolved.GetSignatureForError ()); break; } } if (Kind == MemberKind.Interface && !IsAccessibleAs (fne_resolved)) { Report.Error (61, fne.Location, "Inconsistent accessibility: base interface `{0}' is less accessible than interface `{1}'", fne_resolved.GetSignatureForError (), GetSignatureForError ()); } } else { Report.SymbolRelatedToPreviousError (fne_resolved); if (Kind != MemberKind.Class) { Report.Error (527, fne.Location, "Type `{0}' in interface list is not an interface", fne_resolved.GetSignatureForError ()); } else if (base_class != null) Report.Error (1721, fne.Location, "`{0}': Classes cannot have multiple base classes (`{1}' and `{2}')", GetSignatureForError (), base_class.GetSignatureForError (), fne_resolved.GetSignatureForError ()); else { Report.Error (1722, fne.Location, "`{0}': Base class `{1}' must be specified as first", GetSignatureForError (), fne_resolved.GetSignatureForError ()); } } ifaces [j++] = fne_resolved; } return ifaces; }
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"); }
protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class) { var ifaces = base.ResolveBaseTypes (out base_class); base_type = Compiler.BuiltinTypes.ValueType; return ifaces; }
public virtual void Define (NamespaceContainer ctx) { resolved = expr.ResolveAsTypeOrNamespace (ctx); var ns = resolved as Namespace; if (ns == null) { if (resolved != null) { ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (resolved.Type); ctx.Module.Compiler.Report.Error (138, Location, "`{0}' is a type not a namespace. A using namespace directive can only be applied to namespaces", GetSignatureForError ()); } } }
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 MemberName(string name, TypeParameters tparams, FullNamedExpression explicitInterface, Location loc) : this(name, tparams, loc) { this.ExplicitInterface = explicitInterface; }