protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class) { base_type = Compiler.BuiltinTypes.Object; base_class = null; return null; }
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; }
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 Const (DeclSpace parent, FullNamedExpression type, string name, Expression expr, int mod_flags, Attributes attrs, Location loc) : base (parent, type, mod_flags, AllowedModifiers, new MemberName (name, loc), attrs) { initializer = expr; ModFlags |= Modifiers.STATIC; }
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"); }
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 Const(DeclSpace parent, FullNamedExpression type, string name, Expression expr, Modifiers mod_flags, Attributes attrs, Location loc) : base(parent, type, mod_flags, AllowedModifiers, new MemberName (name, loc), attrs) { if (expr != null) initializer = new ConstInitializer (this, expr); ModFlags |= Modifiers.STATIC; }
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 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 MethodCore (TypeDefinition parent, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, MemberName name, Attributes attrs, ParametersCompiled parameters) : base (parent, type, mod, allowed_mod, name, attrs) { this.parameters = parameters; }
public InteractiveMethod(TypeDefinition parent, FullNamedExpression returnType, Modifiers mod, ParametersCompiled parameters) : base(parent, returnType, mod, new MemberName("Host"), parameters, null) { }
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) { }
GetEnumeratorMethod(IteratorStorey host, FullNamedExpression returnType, MemberName name) : base(host, null, returnType, Modifiers.DEBUGGER_HIDDEN, name, ToplevelBlock.Flags.CompilerGenerated | ToplevelBlock.Flags.NoFlowAnalysis) { }
public Field (TypeContainer parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs) : base (parent, type, mod, AllowedModifiers, name, attrs) { }
public InteractiveMethod(TypeDefinition parent, FullNamedExpression returnType, Modifiers mod, ParametersCompiled parameters) : base(parent, returnType, mod, new MemberName("Host"), parameters, null) { }
public MemberName(MemberName left, string name, FullNamedExpression explicitInterface, Location loc) : this(left, name, loc) { this.ExplicitInterface = explicitInterface; }
public MemberName(string name, TypeParameters tparams, FullNamedExpression explicitInterface, Location loc) : this(name, tparams, loc) { this.ExplicitInterface = explicitInterface; }
protected override TypeSpec[] ResolveBaseTypes(out FullNamedExpression base_class) { base_type = Compiler.BuiltinTypes.Enum; base_class = null; return(null); }
public static FullNamedExpression CreateDelegateTypeExpression(BuiltinTypes builtinTypes, ParametersCompiled parameters, FullNamedExpression retType, Location loc) { bool hasParams = parameters != null && parameters.Count > 0; int paramCount = hasParams ? parameters.Count : 0; bool hasRetType = !(retType is TypeExpression && ((TypeExpression)retType).Type == builtinTypes.Void); int typeParamCount = paramCount; if (hasRetType) { typeParamCount++; } TypeArguments typeArgs = null; if (typeParamCount > 0) { var typeArgArray = new FullNamedExpression[typeParamCount]; for (var i = 0; i < paramCount; i++) { if (i < paramCount) { var param = parameters.FixedParameters[i] as Parameter; typeArgArray[i] = param.TypeExpression; } else { typeArgArray[i] = retType; } } typeArgs = new TypeArguments(typeArgArray); } if (!hasRetType) { return(new MemberAccess(new SimpleName("System", loc), "Action", typeArgs, loc)); } else { return(new MemberAccess(new SimpleName("System", loc), "Func", typeArgs, loc)); } }
TypeSpec FindDocumentedTypeNonArray(MemberCore mc, string identifier, DeclSpace ds, string cref) { var types = module.Compiler.BuiltinTypes; switch (identifier) { case "int": return(types.Int); case "uint": return(types.UInt); case "short": return(types.Short); case "ushort": return(types.UShort); case "long": return(types.Long); case "ulong": return(types.ULong); case "float": return(types.Float); case "double": return(types.Double); case "char": return(types.Char); case "decimal": return(types.Decimal); case "byte": return(types.Byte); case "sbyte": return(types.SByte); case "object": return(types.Object); case "bool": return(types.Bool); case "string": return(types.String); case "void": return(types.Void); } FullNamedExpression e = ds.LookupNamespaceOrType(identifier, 0, mc.Location, false); if (e != null) { if (!(e is TypeExpr)) { return(null); } return(e.Type); } int index = identifier.LastIndexOf('.'); if (index < 0) { return(null); } var nsName = identifier.Substring(0, index); var typeName = identifier.Substring(index + 1); Namespace ns = ds.NamespaceEntry.NS.GetNamespace(nsName, false); ns = ns ?? mc.Module.GlobalRootNamespace.GetNamespace(nsName, false); if (ns != null) { var te = ns.LookupType(mc, typeName, 0, true, mc.Location); if (te != null) { return(te.Type); } } int warn; TypeSpec parent = FindDocumentedType(mc, identifier.Substring(0, index), ds, cref); if (parent == null) { return(null); } // no need to detect warning 419 here var ts = FindDocumentedMember(mc, parent, identifier.Substring(index + 1), null, ds, out warn, cref, false, null) as TypeSpec; if (ts != null) { return(ts); } return(null); }
public DocumentationParameter(FullNamedExpression type) { this.Type = type; }
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; }
protected MemberBase (DeclSpace parent, GenericMethod generic, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, Modifiers def_mod, MemberName name, Attributes attrs) : base (parent, name, attrs) { this.ds = generic != null ? generic : (DeclSpace) parent; this.type_expr = type; ModFlags = ModifiersExtensions.Check (allowed_mod, mod, def_mod, Location, Report); GenericMethod = generic; if (GenericMethod != null) GenericMethod.ModFlags = ModFlags; }
public GetEnumeratorMethod(IteratorStorey host, FullNamedExpression returnType, MemberName name) : base(host, returnType, Modifiers.DEBUGGER_HIDDEN, name) { Block.AddStatement(new GetEnumeratorStatement(host, this)); }
public DocumentationParameter(Parameter.Modifier modifier, FullNamedExpression type) : this(type) { this.Modifier = modifier; }
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 static GetEnumeratorMethod Create(IteratorStorey host, FullNamedExpression returnType, MemberName name) { return(Create(host, returnType, name, null)); }
protected override bool DoDefineMembers() { var builtin_types = Compiler.BuiltinTypes; var ctor_parameters = ParametersCompiled.CreateFullyResolved( new [] { new Parameter(new TypeExpression(builtin_types.Object, Location), "object", Parameter.Modifier.NONE, null, Location), new Parameter(new TypeExpression(builtin_types.IntPtr, Location), "method", Parameter.Modifier.NONE, null, Location) }, new [] { builtin_types.Object, builtin_types.IntPtr } ); Constructor = new Constructor(this, Constructor.ConstructorName, Modifiers.PUBLIC, null, ctor_parameters, null, Location); Constructor.Define(); // // Here the various methods like Invoke, BeginInvoke etc are defined // // First, call the `out of band' special method for // defining recursively any types we need: // var p = parameters; if (!p.Resolve(this)) { return(false); } // // Invoke method // // Check accessibility foreach (var partype in p.Types) { if (!IsAccessibleAs(partype)) { Report.SymbolRelatedToPreviousError(partype); Report.Error(59, Location, "Inconsistent accessibility: parameter type `{0}' is less accessible than delegate `{1}'", TypeManager.CSharpName(partype), GetSignatureForError()); } } ReturnType = ReturnType.ResolveAsType(this); if (ReturnType == null) { return(false); } var ret_type = ReturnType.Type; // // We don't have to check any others because they are all // guaranteed to be accessible - they are standard types. // if (!IsAccessibleAs(ret_type)) { Report.SymbolRelatedToPreviousError(ret_type); Report.Error(58, Location, "Inconsistent accessibility: return type `" + TypeManager.CSharpName(ret_type) + "' is less " + "accessible than delegate `" + GetSignatureForError() + "'"); return(false); } CheckProtectedModifier(); if (Compiler.Settings.StdLib && ret_type.IsSpecialRuntimeType) { Method.Error1599(Location, ret_type, Report); return(false); } TypeManager.CheckTypeVariance(ret_type, Variance.Covariant, this); InvokeBuilder = new Method(this, null, ReturnType, MethodModifiers, new MemberName(InvokeMethodName), p, null); InvokeBuilder.Define(); // // Don't emit async method for compiler generated delegates (e.g. dynamic site containers) // if (!IsCompilerGenerated) { DefineAsyncMethods(Parameters.CallingConvention); } return(true); }
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 static ParametersCompiled CreateImplicitParameter(FullNamedExpression texpr, Location loc) { return(new ParametersCompiled( new[] { new Parameter(texpr, "value", Parameter.Modifier.NONE, null, loc) }, null)); }
public EventProperty (TypeDefinition parent, FullNamedExpression type, Modifiers mod_flags, MemberName name, Attributes attrs) : base (parent, type, mod_flags, name, attrs) { }
public ParamsParameter(FullNamedExpression type, string name, Attributes attrs, Location loc) : base(type, name, Parameter.Modifier.PARAMS, attrs, loc) { }
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; }
private static Type FindDocumentedTypeNonArray(MemberCore mc, string identifier, DeclSpace ds, string cref) { switch (identifier) { case "int": return(TypeManager.int32_type); case "uint": return(TypeManager.uint32_type); case "short": return(TypeManager.short_type);; case "ushort": return(TypeManager.ushort_type); case "long": return(TypeManager.int64_type); case "ulong": return(TypeManager.uint64_type);; case "float": return(TypeManager.float_type);; case "double": return(TypeManager.double_type); case "char": return(TypeManager.char_type);; case "decimal": return(TypeManager.decimal_type);; case "byte": return(TypeManager.byte_type);; case "sbyte": return(TypeManager.sbyte_type);; case "object": return(TypeManager.object_type);; case "bool": return(TypeManager.bool_type);; case "string": return(TypeManager.string_type);; case "void": return(TypeManager.void_type);; } FullNamedExpression e = ds.LookupNamespaceOrType(identifier, mc.Location, false); if (e != null) { if (!(e is TypeExpr)) { return(null); } return(e.Type); } int index = identifier.LastIndexOf('.'); if (index < 0) { return(null); } int warn; Type parent = FindDocumentedType(mc, identifier.Substring(0, index), ds, cref); if (parent == null) { return(null); } // no need to detect warning 419 here return(FindDocumentedMember(mc, parent, identifier.Substring(index + 1), null, ds, out warn, cref, false, null).Member as Type); }
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) { }
public FixedField(TypeDefinition parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs) : base(parent, type, mod, AllowedModifiers, name, attrs) { }
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) { }
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 InterfaceMemberBase (DeclSpace parent, GenericMethod generic, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, MemberName name, Attributes attrs) : base (parent, generic, type, mod, allowed_mod, Modifiers.PRIVATE, name, attrs) { IsInterface = parent.PartialContainer.Kind == MemberKind.Interface; IsExplicitImpl = (MemberName.ExplicitInterface != null); explicit_mod_flags = mod; }
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; }
TypeSpec[] GetNormalPartialBases () { var ifaces = new List<TypeSpec> (0); if (iface_exprs != null) ifaces.AddRange (iface_exprs); foreach (TypeContainer part in partial_parts) { FullNamedExpression new_base_class; var new_ifaces = part.ResolveBaseTypes (out new_base_class); if (new_base_class != null) { if (base_type_expr != null && part.base_type != base_type) { Report.SymbolRelatedToPreviousError (new_base_class.Location, ""); Report.Error (263, part.Location, "Partial declarations of `{0}' must not specify different base classes", part.GetSignatureForError ()); } else { base_type_expr = new_base_class; base_type = part.base_type; } } if (new_ifaces == null) continue; foreach (var iface in new_ifaces) { if (ifaces.Contains (iface)) continue; ifaces.Add (iface); } } if (ifaces.Count == 0) return null; return ifaces.ToArray (); }
protected Field AddCompilerGeneratedField (string name, FullNamedExpression type) { return AddCompilerGeneratedField (name, type, false); }
/// <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; }
// // 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) { var ifaces = base.ResolveBaseTypes (out base_class); base_type = Compiler.BuiltinTypes.ValueType; return ifaces; }
private static TypeSpec FindDocumentedTypeNonArray(MemberCore mc, string identifier, DeclSpace ds, string cref, Report r) { switch (identifier) { case "int": return(TypeManager.int32_type); case "uint": return(TypeManager.uint32_type); case "short": return(TypeManager.short_type);; case "ushort": return(TypeManager.ushort_type); case "long": return(TypeManager.int64_type); case "ulong": return(TypeManager.uint64_type);; case "float": return(TypeManager.float_type);; case "double": return(TypeManager.double_type); case "char": return(TypeManager.char_type);; case "decimal": return(TypeManager.decimal_type);; case "byte": return(TypeManager.byte_type);; case "sbyte": return(TypeManager.sbyte_type);; case "object": return(TypeManager.object_type);; case "bool": return(TypeManager.bool_type);; case "string": return(TypeManager.string_type);; case "void": return(TypeManager.void_type);; } FullNamedExpression e = ds.LookupNamespaceOrType(identifier, 0, mc.Location, false); if (e != null) { if (!(e is TypeExpr)) { return(null); } return(e.Type); } int index = identifier.LastIndexOf('.'); if (index < 0) { return(null); } var nsName = identifier.Substring(0, index); var typeName = identifier.Substring(index + 1); Namespace ns = ds.NamespaceEntry.NS.GetNamespace(nsName, false); ns = ns ?? mc.Module.GlobalRootNamespace.GetNamespace(nsName, false); if (ns != null) { var te = ns.LookupType(mc.Compiler, typeName, 0, true, mc.Location); if (te != null) { return(te.Type); } } int warn; TypeSpec parent = FindDocumentedType(mc, identifier.Substring(0, index), ds, cref, r); if (parent == null) { return(null); } // no need to detect warning 419 here var ts = FindDocumentedMember(mc, parent, identifier.Substring(index + 1), null, ds, out warn, cref, false, null, r) as TypeSpec; if (ts != null) { return(ts); } return(null); }
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 RoleField(DeclSpace parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs) : base(parent, type, mod, name, attrs) { }
protected Field AddCompilerGeneratedField (string name, FullNamedExpression type, bool privateAccess) { Modifiers mod = Modifiers.COMPILER_GENERATED | (privateAccess ? Modifiers.PRIVATE : Modifiers.INTERNAL); Field f = new Field (this, type, mod, new MemberName (name, Location), null); AddField (f); return f; }
public Self(string roleContractName, FullNamedExpression type, string name, Modifier mod, Attributes attrs, Location loc) : base(type, name, mod, attrs, loc) { _roleContractName = roleContractName; }
public HoistedField (HoistedStoreyClass parent, FullNamedExpression type, Modifiers mod, string name, Attributes attrs, Location loc) : base (parent, type, mod, new MemberName (name, loc), attrs) { }
GetEnumeratorMethod(IteratorStorey host, FullNamedExpression returnType, MemberName name) : base(host, null, returnType, Modifiers.DEBUGGER_HIDDEN, name) { }