XmlNode GetDocCommentNode (MemberCore mc, string name) { // FIXME: It could be even optimizable as not // to use XmlDocument. But anyways the nodes // are not kept in memory. XmlDocument doc = XmlDocumentation; try { XmlElement el = doc.CreateElement ("member"); el.SetAttribute ("name", name); string normalized = mc.DocComment; el.InnerXml = normalized; // csc keeps lines as written in the sources // and inserts formatting indentation (which // is different from XmlTextWriter.Formatting // one), but when a start tag contains an // endline, it joins the next line. We don't // have to follow such a hacky behavior. string [] split = normalized.Split ('\n'); int j = 0; for (int i = 0; i < split.Length; i++) { string s = split [i].TrimEnd (); if (s.Length > 0) split [j++] = s; } el.InnerXml = line_head + String.Join ( line_head, split, 0, j); return el; } catch (Exception ex) { Report.Warning (1570, 1, mc.Location, "XML documentation comment on `{0}' is not well-formed XML markup ({1})", mc.GetSignatureForError (), ex.Message); return doc.CreateComment (String.Format ("FIXME: Invalid documentation markup was found for member {0}", name)); } }
// TODO: merge method and mb public ReturnParameter (MemberCore method, MethodBuilder mb, Location location) { this.method = method; try { builder = mb.DefineParameter (0, ParameterAttributes.None, ""); } catch (ArgumentOutOfRangeException) { method.Compiler.Report.RuntimeMissingSupport (location, "custom attributes on the return type"); } }
XmlNode GetDocCommentNode (MemberCore mc, string name) { // FIXME: It could be even optimizable as not // to use XmlDocument. But anyways the nodes // are not kept in memory. XmlDocument doc = XmlDocumentation; try { XmlElement el = doc.CreateElement ("member"); el.SetAttribute ("name", name); string normalized = mc.DocComment; el.InnerXml = normalized; string [] split = normalized.Split ('\n'); el.InnerXml = line_head + String.Join (line_head, split); return el; } catch (Exception ex) { Report.Warning (1570, 1, mc.Location, "XML documentation comment on `{0}' is not well-formed XML markup ({1})", mc.GetSignatureForError (), ex.Message); return doc.CreateComment (String.Format ("FIXME: Invalid documentation markup was found for member {0}", name)); } }
public bool AddMember (MemberCore symbol) { return AddToContainer (symbol, symbol.MemberName.Basename); }
public override bool EnableOverloadChecks (MemberCore overload) { if (overload is MethodCore) { caching_flags |= Flags.MethodOverloadsExist; return true; } // This can only happen with indexers and it will // be catched as indexer difference if (overload is AbstractPropertyEventMethod) return true; return false; }
// // Processes "see" or "seealso" elements. // Checks cref attribute. // private static void HandleXrefCommon(MemberCore mc, DeclSpace ds, XmlElement xref, Report Report) { string cref = xref.GetAttribute("cref").Trim(wsChars); // when, XmlReader, "if (cref == null)" if (!xref.HasAttribute("cref")) { return; } if (cref.Length == 0) { Report.Warning(1001, 1, mc.Location, "Identifier expected"); } // ... and continue until CS1584. else { // Additional symbols for < and > are allowed for easier XML typing cref = cref.Replace('{', '<').Replace('}', '>'); } string signature; // "x:" are stripped string name; // method invokation "(...)" are removed string parameters; // method parameter list // When it found '?:' ('T:' 'M:' 'F:' 'P:' 'E:' etc.), // MS ignores not only its member kind, but also // the entire syntax correctness. Nor it also does // type fullname resolution i.e. "T:List(int)" is kept // as T:List(int), not // T:System.Collections.Generic.List<System.Int32> if (cref.Length > 2 && cref [1] == ':') { return; } else { signature = cref; } // Also note that without "T:" any generic type // indication fails. int parens_pos = signature.IndexOf('('); int brace_pos = parens_pos >= 0 ? -1 : signature.IndexOf('['); if (parens_pos > 0 && signature [signature.Length - 1] == ')') { name = signature.Substring(0, parens_pos).Trim(wsChars); parameters = signature.Substring(parens_pos + 1, signature.Length - parens_pos - 2).Trim(wsChars); } else if (brace_pos > 0 && signature [signature.Length - 1] == ']') { name = signature.Substring(0, brace_pos).Trim(wsChars); parameters = signature.Substring(brace_pos + 1, signature.Length - brace_pos - 2).Trim(wsChars); } else { name = signature; parameters = null; } Normalize(mc, ref name, Report); string identifier = GetBodyIdentifierFromName(name); // Check if identifier is valid. // This check is not necessary to mark as error, but // csc specially reports CS1584 for wrong identifiers. string [] name_elems = identifier.Split('.'); for (int i = 0; i < name_elems.Length; i++) { string nameElem = GetBodyIdentifierFromName(name_elems [i]); if (i > 0) { Normalize(mc, ref nameElem, Report); } if (!Tokenizer.IsValidIdentifier(nameElem) && nameElem.IndexOf("operator") < 0) { Report.Warning(1584, 1, mc.Location, "XML comment on `{0}' has syntactically incorrect cref attribute `{1}'", mc.GetSignatureForError(), cref); xref.SetAttribute("cref", "!:" + signature); return; } } // check if parameters are valid Type [] parameter_types; if (parameters == null) { parameter_types = null; } else if (parameters.Length == 0) { parameter_types = Type.EmptyTypes; } else { string [] param_list = parameters.Split(','); ArrayList plist = new ArrayList(); for (int i = 0; i < param_list.Length; i++) { string param_type_name = param_list [i].Trim(wsChars); Normalize(mc, ref param_type_name, Report); Type param_type = FindDocumentedType(mc, param_type_name, ds, cref, Report); if (param_type == null) { Report.Warning(1580, 1, mc.Location, "Invalid type for parameter `{0}' in XML comment cref attribute `{1}'", (i + 1).ToString(), cref); return; } plist.Add(param_type); } parameter_types = plist.ToArray(typeof(Type)) as Type []; } Type type = FindDocumentedType(mc, name, ds, cref, Report); if (type != null // delegate must not be referenced with args && (!TypeManager.IsDelegateType(type) || parameter_types == null)) { string result = GetSignatureForDoc(type) + (brace_pos < 0 ? String.Empty : signature.Substring(brace_pos)); xref.SetAttribute("cref", "T:" + result); return; // a type } int period = name.LastIndexOf('.'); if (period > 0) { string typeName = name.Substring(0, period); string member_name = name.Substring(period + 1); Normalize(mc, ref member_name, Report); type = FindDocumentedType(mc, typeName, ds, cref, Report); int warn_result; if (type != null) { FoundMember fm = FindDocumentedMember(mc, type, member_name, parameter_types, ds, out warn_result, cref, true, name, Report); if (warn_result > 0) { return; } if (!fm.IsEmpty) { MemberInfo mi = fm.Member; // we cannot use 'type' directly // to get its name, since mi // could be from DeclaringType // for nested types. xref.SetAttribute("cref", GetMemberDocHead(mi.MemberType) + GetSignatureForDoc(fm.Type) + "." + member_name + GetParametersFormatted(mi)); return; // a member of a type } } } else { int warn_result; FoundMember fm = FindDocumentedMember(mc, ds.TypeBuilder, name, parameter_types, ds, out warn_result, cref, true, name, Report); if (warn_result > 0) { return; } if (!fm.IsEmpty) { MemberInfo mi = fm.Member; // we cannot use 'type' directly // to get its name, since mi // could be from DeclaringType // for nested types. xref.SetAttribute("cref", GetMemberDocHead(mi.MemberType) + GetSignatureForDoc(fm.Type) + "." + name + GetParametersFormatted(mi)); return; // local member name } } // It still might be part of namespace name. Namespace ns = ds.NamespaceEntry.NS.GetNamespace(name, false); if (ns != null) { xref.SetAttribute("cref", "N:" + ns.GetSignatureForError()); return; // a namespace } if (GlobalRootNamespace.Instance.IsNamespace(name)) { xref.SetAttribute("cref", "N:" + name); return; // a namespace } Report.Warning(1574, 1, mc.Location, "XML comment on `{0}' has cref attribute `{1}' that could not be resolved", mc.GetSignatureForError(), cref); xref.SetAttribute("cref", "!:" + name); }
public void ResolveDefaultValues (MemberCore m) { ResolveContext rc = null; for (int i = 0; i < parameters.Length; ++i) { Parameter p = (Parameter) parameters [i]; // // Try not to enter default values resolution if there are is not any default value possible // if (p.HasDefaultValue || p.OptAttributes != null) { if (rc == null) rc = new ResolveContext (m); p.ResolveDefaultValue (rc); } } }
private void AddMemberToList (MemberCore mc, List<MemberCore> alist, bool isexplicit) { if (ordered_explicit_member_list == null) { ordered_explicit_member_list = new List<MemberCore> (); ordered_member_list = new List<MemberCore> (); } if (isexplicit) { if (Kind == MemberKind.Interface) { Report.Error (541, mc.Location, "`{0}': explicit interface declaration can only be declared in a class or struct", mc.GetSignatureForError ()); } ordered_explicit_member_list.Add (mc); alist.Insert (0, mc); } else { ordered_member_list.Add (mc); alist.Add (mc); } }
// // Adds the member to defined_names table. It tests for duplications and enclosing name conflicts // public virtual void AddNameToContainer (MemberCore symbol, string name) { if (((ModFlags | symbol.ModFlags) & Modifiers.COMPILER_GENERATED) != 0) return; MemberCore mc; if (!PartialContainer.defined_names.TryGetValue (name, out mc)) { PartialContainer.defined_names.Add (name, symbol); return; } if (symbol.EnableOverloadChecks (mc)) return; InterfaceMemberBase im = mc as InterfaceMemberBase; if (im != null && im.IsExplicitImpl) return; Report.SymbolRelatedToPreviousError (mc); if ((mc.ModFlags & Modifiers.PARTIAL) != 0 && (symbol is ClassOrStruct || symbol is Interface)) { Error_MissingPartialModifier (symbol); return; } if (symbol is TypeParameter) { Report.Error (692, symbol.Location, "Duplicate type parameter `{0}'", symbol.GetSignatureForError ()); } else { Report.Error (102, symbol.Location, "The type `{0}' already contains a definition for `{1}'", GetSignatureForError (), name); } return; }
protected void Error_MissingPartialModifier (MemberCore type) { Report.Error (260, type.Location, "Missing partial modifier on declaration of type `{0}'. Another partial declaration of this type exists", type.GetSignatureForError ()); }
public virtual void Visit(MemberCore member) { Console.WriteLine("unknown member: " + member); }
// // Handles <exception> elements. // void HandleException(MemberCore mc, DeclSpace ds, XmlElement seealso) { HandleXrefCommon(mc, ds, seealso); }
// // Handles <see> elements. // void HandleSee(MemberCore mc, DeclSpace ds, XmlElement see) { HandleXrefCommon(mc, ds, see); }
public static string GetMethodDocCommentName(MemberCore mc, ParametersCompiled p, DeclSpace ds) { return(""); }
internal static void GenerateDocComment(MemberCore mc, DeclSpace ds, Report r) { }
public static void Error_CyclicDeclaration(MemberCore mc) { Report.Error(110, mc.Location, "The evaluation of the constant value for `{0}' involves a circular definition", mc.GetSignatureForError()); }
// // Performs the validation on a Method's modifiers (properties have // the same properties). // // TODO: Why is it not done at parse stage, move to Modifiers::Check // public bool MethodModifiersValid (MemberCore mc) { const Modifiers vao = (Modifiers.VIRTUAL | Modifiers.ABSTRACT | Modifiers.OVERRIDE); const Modifiers nv = (Modifiers.NEW | Modifiers.VIRTUAL); bool ok = true; var flags = mc.ModFlags; // // At most one of static, virtual or override // if ((flags & Modifiers.STATIC) != 0){ if ((flags & vao) != 0){ Report.Error (112, mc.Location, "A static member `{0}' cannot be marked as override, virtual or abstract", mc.GetSignatureForError ()); ok = false; } } if ((flags & Modifiers.OVERRIDE) != 0 && (flags & nv) != 0){ Report.Error (113, mc.Location, "A member `{0}' marked as override cannot be marked as new or virtual", mc.GetSignatureForError ()); ok = false; } // // If the declaration includes the abstract modifier, then the // declaration does not include static, virtual or extern // if ((flags & Modifiers.ABSTRACT) != 0){ if ((flags & Modifiers.EXTERN) != 0){ Report.Error ( 180, mc.Location, "`{0}' cannot be both extern and abstract", mc.GetSignatureForError ()); ok = false; } if ((flags & Modifiers.SEALED) != 0) { Report.Error (502, mc.Location, "`{0}' cannot be both abstract and sealed", mc.GetSignatureForError ()); ok = false; } if ((flags & Modifiers.VIRTUAL) != 0){ Report.Error (503, mc.Location, "The abstract method `{0}' cannot be marked virtual", mc.GetSignatureForError ()); ok = false; } if ((ModFlags & Modifiers.ABSTRACT) == 0){ Report.SymbolRelatedToPreviousError (this); Report.Error (513, mc.Location, "`{0}' is abstract but it is declared in the non-abstract class `{1}'", mc.GetSignatureForError (), GetSignatureForError ()); ok = false; } } if ((flags & Modifiers.PRIVATE) != 0){ if ((flags & vao) != 0){ Report.Error (621, mc.Location, "`{0}': virtual or abstract members cannot be private", mc.GetSignatureForError ()); ok = false; } } if ((flags & Modifiers.SEALED) != 0){ if ((flags & Modifiers.OVERRIDE) == 0){ Report.Error (238, mc.Location, "`{0}' cannot be sealed because it is not an override", mc.GetSignatureForError ()); ok = false; } } return ok; }
public override void RegisterFieldForInitialization (MemberCore field, FieldInitializer expression) { if ((field.ModFlags & Modifiers.STATIC) == 0) { Report.Error (573, field.Location, "`{0}': Structs cannot have instance field initializers", field.GetSignatureForError ()); return; } base.RegisterFieldForInitialization (field, expression); }
// // Generates xml doc comments (if any), and if required, // handle warning report. // internal void GenerateDocumentationForMember(MemberCore mc) { }
protected void Error_CannotChangeAccessModifiers (MemberCore member, MemberSpec base_member) { var base_modifiers = base_member.Modifiers; // Remove internal modifier from types which are not internally accessible if ((base_modifiers & Modifiers.AccessibilityMask) == (Modifiers.PROTECTED | Modifiers.INTERNAL) && !base_member.DeclaringType.MemberDefinition.IsInternalAsPublic (member.Module.DeclaringAssembly)) base_modifiers = Modifiers.PROTECTED; Report.SymbolRelatedToPreviousError (base_member); Report.Error (507, member.Location, "`{0}': cannot change access modifiers when overriding `{1}' inherited member `{2}'", member.GetSignatureForError (), ModifiersExtensions.AccessibilityName (base_modifiers), base_member.GetSignatureForError ()); }
public Expression TryInline(ResolveContext rc) { if (!(Expr is Invocation)) { return(Expr); } invocation = (Expr as Invocation); if (invocation.MethodGroup.BestCandidate == null) { return(Expr); } methodSpec = invocation.MethodGroup.BestCandidate; if (!(methodSpec.MemberDefinition is MethodCore)) { return(Expr); } method = methodSpec.MemberDefinition as MemberCore; methodData = method as IMethodData; if (methodData.IsInlinable) { return(Expr); } TypeSpec returnType = methodData.ReturnType; ToplevelBlock block = methodData.Block; if (block.Parameters.Count > 0 || block.TopBlock.NamesCount > 0 && block.TopBlock.LabelsCount > 0) { return(Expr); } if (returnType != rc.BuiltinTypes.Void && block.Statements.Count == 1 && block.Statements [0] is Return) { inlineExpr = ((Return)block.Statements [0]).Expr.Clone(new CloneContext()); } else if (returnType == rc.BuiltinTypes.Void) { Block newBlock = new Block(rc.CurrentBlock, block.StartLocation, block.EndLocation); foreach (var st in block.Statements) { newBlock.AddStatement(st.Clone(new CloneContext())); } // inlineExpr = newBlock; } this.inlineFailed = false; Expression ret; inlineExpr.Accept(this); ret = inlineExpr; if (inlineFailed) { return(Expr); } return(ret); }
private static Type 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, 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, r); 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, r).Member as Type); }
public InlinableValidator(MemberCore method) { this.method = method; }
// // Parameters checks for members which don't have a block // public void CheckParameters (MemberCore member) { for (int i = 0; i < parameters.Length; ++i) { var name = parameters[i].Name; for (int ii = i + 1; ii < parameters.Length; ++ii) { if (parameters[ii].Name == name) this[ii].Error_DuplicateName (member.Compiler.Report); } } }
public override bool EnableOverloadChecks (MemberCore overload) { if (overload is Indexer) { caching_flags |= Flags.MethodOverloadsExist; return true; } return base.EnableOverloadChecks (overload); }
public override bool EnableOverloadChecks (MemberCore overload) { if (overload is Indexer) return false; return base.EnableOverloadChecks (overload); }
private static MemberInfo FindDocumentedMemberNoNest( MemberCore mc, Type type, string member_name, Type [] param_list, DeclSpace ds, out int warning_type, string cref, bool warn419, string name_for_error, Report Report) { warning_type = 0; MemberInfo [] mis; if (param_list == null) { // search for fields/events etc. mis = TypeManager.MemberLookup(type, null, type, MemberTypes.All, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance, member_name, null); mis = FilterOverridenMembersOut(mis); if (mis == null || mis.Length == 0) { return(null); } if (warn419 && IsAmbiguous(mis)) { Report419(mc, name_for_error, mis, Report); } return(mis [0]); } MethodSignature msig = new MethodSignature(member_name, null, param_list); mis = FindMethodBase(type, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance, msig); if (warn419 && mis.Length > 0) { if (IsAmbiguous(mis)) { Report419(mc, name_for_error, mis, Report); } return(mis [0]); } // search for operators (whose parameters exactly // matches with the list) and possibly report CS1581. string oper = null; string return_type_name = null; if (member_name.StartsWith("implicit operator ")) { Operator.GetMetadataName(Operator.OpType.Implicit); return_type_name = member_name.Substring(18).Trim(wsChars); } else if (member_name.StartsWith("explicit operator ")) { oper = Operator.GetMetadataName(Operator.OpType.Explicit); return_type_name = member_name.Substring(18).Trim(wsChars); } else if (member_name.StartsWith("operator ")) { oper = member_name.Substring(9).Trim(wsChars); switch (oper) { // either unary or binary case "+": oper = param_list.Length == 2 ? Operator.GetMetadataName(Operator.OpType.Addition) : Operator.GetMetadataName(Operator.OpType.UnaryPlus); break; case "-": oper = param_list.Length == 2 ? Operator.GetMetadataName(Operator.OpType.Subtraction) : Operator.GetMetadataName(Operator.OpType.UnaryNegation); break; default: oper = Operator.GetMetadataName(oper); if (oper != null) { break; } warning_type = 1584; Report.Warning(1020, 1, mc.Location, "Overloadable {0} operator is expected", param_list.Length == 2 ? "binary" : "unary"); Report.Warning(1584, 1, mc.Location, "XML comment on `{0}' has syntactically incorrect cref attribute `{1}'", mc.GetSignatureForError(), cref); return(null); } } // here we still don't consider return type (to // detect CS1581 or CS1002+CS1584). msig = new MethodSignature(oper, null, param_list); mis = FindMethodBase(type, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance, msig); if (mis.Length == 0) { return(null); // CS1574 } MemberInfo mi = mis [0]; Type expected = mi is MethodInfo ? ((MethodInfo)mi).ReturnType : mi is PropertyInfo ? ((PropertyInfo)mi).PropertyType : null; if (return_type_name != null) { Type returnType = FindDocumentedType(mc, return_type_name, ds, cref, Report); if (returnType == null || returnType != expected) { warning_type = 1581; Report.Warning(1581, 1, mc.Location, "Invalid return type in XML comment cref attribute `{0}'", cref); return(null); } } return(mis [0]); }
public override void Visit (MemberCore member) { Console.WriteLine ("Unknown member:"); Console.WriteLine (member.GetType () + "-> Member {0}", member.GetSignatureForError ()); }
public virtual void Visit(MemberCore member) { Console.WriteLine("unknown member type: " + member.GetType()); }
public override bool EnableOverloadChecks (MemberCore overload) { if (overload is MethodCore) { caching_flags |= Flags.MethodOverloadsExist; return true; } if (overload is AbstractPropertyEventMethod) return true; return base.EnableOverloadChecks (overload); }
public virtual void Visit(MemberCore member) { Debug.Fail("unknown member type: " + member.GetType()); }
public void RegisterFieldForInitialization (MemberCore field, FieldInitializer expression) { if (IsPartialPart) PartialContainer.RegisterFieldForInitialization (field, expression); if ((field.ModFlags & Modifiers.STATIC) != 0){ if (initialized_static_fields == null) { HasStaticFieldInitializer = true; initialized_static_fields = new List<FieldInitializer> (4); } initialized_static_fields.Add (expression); } else { if (Kind == MemberKind.Struct) { if (Compiler.Settings.Version != LanguageVersion.Experimental) { Report.Error (573, expression.Location, "'{0}': Structs cannot have instance property or field initializers", GetSignatureForError ()); } } if (initialized_fields == null) initialized_fields = new List<FieldInitializer> (4); initialized_fields.Add (expression); } }
public override bool EnableOverloadChecks (MemberCore overload) { // TODO: It can be deleted when members will be defined in correct order if (overload is Operator) return overload.EnableOverloadChecks (this); if (overload is Indexer) return false; return base.EnableOverloadChecks (overload); }
public bool AddMember (MemberCore symbol, string name) { return AddToContainer (symbol, name); }
/// <summary> /// Adds the member to defined_names table. It tests for duplications and enclosing name conflicts /// </summary> protected virtual bool AddToContainer (MemberCore symbol, string name) { MemberCore mc; if (!defined_names.TryGetValue (name, out mc)) { defined_names.Add (name, symbol); return true; } if (((mc.ModFlags | symbol.ModFlags) & Modifiers.COMPILER_GENERATED) != 0) return true; if (symbol.EnableOverloadChecks (mc)) return true; InterfaceMemberBase im = mc as InterfaceMemberBase; if (im != null && im.IsExplicitImpl) return true; Report.SymbolRelatedToPreviousError (mc); if ((mc.ModFlags & Modifiers.PARTIAL) != 0 && (symbol is ClassOrStruct || symbol is Interface)) { Error_MissingPartialModifier (symbol); return false; } if (this is ModuleContainer) { Report.Error (101, symbol.Location, "The namespace `{0}' already contains a definition for `{1}'", ((DeclSpace)symbol).NamespaceEntry.GetSignatureForError (), symbol.MemberName.Name); } else if (symbol is TypeParameter) { Report.Error (692, symbol.Location, "Duplicate type parameter `{0}'", symbol.GetSignatureForError ()); } else { Report.Error (102, symbol.Location, "The type `{0}' already contains a definition for `{1}'", GetSignatureForError (), symbol.MemberName.Name); } return false; }
public override void AddNameToContainer (MemberCore symbol, string name) { if (!(symbol is Constructor) && symbol.MemberName.Name == MemberName.Name) { if (symbol is TypeParameter) { Report.Error (694, symbol.Location, "Type parameter `{0}' has same name as containing type, or method", symbol.GetSignatureForError ()); return; } InterfaceMemberBase imb = symbol as InterfaceMemberBase; if (imb == null || !imb.IsExplicitImpl) { Report.SymbolRelatedToPreviousError (this); Report.Error (542, symbol.Location, "`{0}': member names cannot be the same as their enclosing type", symbol.GetSignatureForError ()); return; } } base.AddNameToContainer (symbol, name); }
protected override bool AddToContainer (MemberCore symbol, string name) { MemberCore mc = GetDefinition (name); if (mc == null) { defined_names.Add (name, symbol); return true; } // A conflict between anonymous type members will be reported if (symbol is TypeParameter) { Report.SymbolRelatedToPreviousError (symbol); return false; } // Ignore other conflicts return true; }
protected static bool CheckAccessModifiers (MemberCore this_member, MemberSpec base_member) { var thisp = this_member.ModFlags & Modifiers.AccessibilityMask; var base_classp = base_member.Modifiers & Modifiers.AccessibilityMask; if ((base_classp & (Modifiers.PROTECTED | Modifiers.INTERNAL)) == (Modifiers.PROTECTED | Modifiers.INTERNAL)) { // // It must be at least "protected" // if ((thisp & Modifiers.PROTECTED) == 0) { return false; } // // when overriding protected internal, the method can be declared // protected internal only within the same assembly or assembly // which has InternalsVisibleTo // if ((thisp & Modifiers.INTERNAL) != 0) { return base_member.DeclaringType.MemberDefinition.IsInternalAsPublic (this_member.Module.DeclaringAssembly); } // // protected overriding protected internal inside same assembly // requires internal modifier as well // if (base_member.DeclaringType.MemberDefinition.IsInternalAsPublic (this_member.Module.DeclaringAssembly)) { return false; } return true; } return thisp == base_classp; }
/// <summary> /// Returns true when a member supports multiple overloads (methods, indexers, etc) /// </summary> public virtual bool EnableOverloadChecks (MemberCore overload) { return false; }
public override bool EnableOverloadChecks (MemberCore overload) { // // Two members can differ in their explicit interface // type parameter only // InterfaceMemberBase imb = overload as InterfaceMemberBase; if (imb != null && imb.IsExplicitImpl) { if (IsExplicitImpl) { caching_flags |= Flags.MethodOverloadsExist; } return true; } return IsExplicitImpl; }
public InternalErrorException (MemberCore mc, Exception e) : base (mc.Location + " " + mc.GetSignatureForError (), e) { }
public void AddMember (MemberCore symbol) { if (symbol.MemberName.ExplicitInterface != null) { if (!(Kind == MemberKind.Class || Kind == MemberKind.Struct)) { Report.Error (541, symbol.Location, "`{0}': explicit interface declaration can only be declared in a class or struct", symbol.GetSignatureForError ()); } } AddNameToContainer (symbol, symbol.MemberName.Basename); members.Add (symbol); }
public void SymbolRelatedToPreviousError (MemberCore mc) { SymbolRelatedToPreviousError (mc.Location, mc.GetSignatureForError ()); }
public virtual void RegisterFieldForInitialization (MemberCore field, FieldInitializer expression) { if (IsPartialPart) PartialContainer.RegisterFieldForInitialization (field, expression); if ((field.ModFlags & Modifiers.STATIC) != 0){ if (initialized_static_fields == null) { HasStaticFieldInitializer = true; initialized_static_fields = new List<FieldInitializer> (4); } initialized_static_fields.Add (expression); } else { if (initialized_fields == null) initialized_fields = new List<FieldInitializer> (4); initialized_fields.Add (expression); } }
// // Handles <exception> elements. // private static void HandleException(MemberCore mc, DeclSpace ds, XmlElement seealso, Report r) { HandleXrefCommon(mc, ds, seealso, r); }