private static MemberCache GetMemberCache(Type type){ MemberCache memberCache = null; if (!s_memberCache.TryGetValue(type, out memberCache)) { memberCache = new MemberCache(); s_memberCache.TryAdd(type, memberCache); } return memberCache; }
protected override bool CheckBase() { if (!base.CheckBase()) { return(false); } MemberSpec candidate; bool overrides = false; var conflict_symbol = MemberCache.FindBaseMember(this, out candidate, ref overrides); if (conflict_symbol == null) { conflict_symbol = candidate; } if (conflict_symbol == null) { if ((ModFlags & Modifiers.NEW) != 0) { Report.Warning(109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required", GetSignatureForError()); } } else { if ((ModFlags & (Modifiers.NEW | Modifiers.OVERRIDE | Modifiers.BACKING_FIELD)) == 0) { Report.SymbolRelatedToPreviousError(conflict_symbol); Report.Warning(108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended", GetSignatureForError(), conflict_symbol.GetSignatureForError()); } if (conflict_symbol.IsAbstract) { Report.SymbolRelatedToPreviousError(conflict_symbol); Report.Error(533, Location, "`{0}' hides inherited abstract member `{1}'", GetSignatureForError(), conflict_symbol.GetSignatureForError()); } } return(true); }
private static string GetEventWire(MemberCache cache) { var ctorOfEventHandler = typeof(EventHandler).GetConstructorsOfType(false).First(); foreach (var use in cache.UsedBy) { if (use.Member is MethodInfo) { var usedInMethod = (MethodInfo)use.Member; var ilinstructions = usedInMethod.GetILInstructions(); string eventName = ""; var instructionUsed = ilinstructions.Where(il => il.Offset == use.Offset).FirstOrDefault(); if (instructionUsed != null) { if (instructionUsed.Code == OpCodes.Ldftn && instructionUsed.Next != null && instructionUsed.Next.Code == OpCodes.Newobj && (ConstructorInfo)instructionUsed.Next.Operand == ctorOfEventHandler) { // it's about to get registered to an event var wireInstruction = instructionUsed.Next.Next; if (wireInstruction != null && wireInstruction.Code.FlowControl == FlowControl.Call && wireInstruction.Operand is MethodInfo) { // this should be the eventname if it isn't obfuscated eventName = ((MethodInfo)(wireInstruction.Operand)).Name.Replace("add_", ""); // search for the field that has the event if (instructionUsed.Previous != null && instructionUsed.Previous.Previous != null) { var loadFieldInstruction = instructionUsed.Previous.Previous; if (loadFieldInstruction.Code == OpCodes.Ldfld || loadFieldInstruction.Code == OpCodes.Ldflda) { eventName = ((FieldInfo)loadFieldInstruction.Operand).GetName(false) + "_" + eventName; } } return(eventName); } } } } } return(null); }
public Editor() { InitializeComponent(); TheEditor = this; MemberCache.Import(); this.Text += ' ' + Program.getVersion() + " (" + IBMi.CurrentSystem.GetValue("alias") + ")"; if (!IBMi.IsConnected()) { this.Text += " - Offline Mode"; } if (IBMi.IsConnected()) { if (IBMi.CurrentSystem.GetValue("lastOffline") == "true") { DialogResult result = MessageBox.Show("Looks like your last session was in Offline Mode. Would you like the launch the SPF Push tool?", "Notice", MessageBoxButtons.YesNo, MessageBoxIcon.Information); if (result == DialogResult.Yes) { new Forms.PushWindow().ShowDialog(); } } } IBMi.CurrentSystem.SetValue("lastOffline", (IBMi.IsConnected() == false).ToString().ToLower()); if (Program.Config.GetValue("darkmode") == "true") { dockingPanel.Theme = new VS2015DarkTheme(); } else { dockingPanel.Theme = new VS2015LightTheme(); } AddTool(new UserTools.Welcome()); AddTool(new UserTools.UserToolList(), DockState.DockLeft); OutlineView = new UserTools.OutlineView(); AddTool(OutlineView, DockState.DockRightAutoHide); }
public override void EmitStatement(EmitContext ec) { var storey = (AsyncTaskStorey)Storey; storey.Instance.Emit(ec); var move_next_entry = storey.StateMachineMethod.Spec; if (storey.MemberName.Arity > 0) { move_next_entry = MemberCache.GetMember(storey.Instance.Type, move_next_entry); } ec.Emit(OpCodes.Call, move_next_entry); // // Emits return <async-storey-instance>.$builder.Task; // if (storey.Task != null) { var builder_field = storey.Builder.Spec; var task_get = storey.Task.Get; if (storey.MemberName.Arity > 0) { builder_field = MemberCache.GetMember(storey.Instance.Type, builder_field); task_get = MemberCache.GetMember(builder_field.MemberType, task_get); } var pe_task = new PropertyExpr(storey.Task, loc) { InstanceExpression = new FieldExpr(builder_field, loc) { InstanceExpression = storey.Instance }, Getter = task_get }; pe_task.Emit(ec); } ec.Emit(OpCodes.Ret); }
protected override Expression DoResolve(ResolveContext ec) { var members = MemberCache.GetCompletitionMembers(ec, ec.CurrentInitializerVariable.Type, partial_name); // TODO: Does this mean exact match only ? // if (partial_name != null && results.Count > 0 && result [0] == "") // throw new CompletionResult ("", new string [] { "=" }); var results = members.Where(l => (l.Kind & (MemberKind.Field | MemberKind.Property)) != 0).Select(l => l.Name).ToList(); if (partial_name != null) { var temp = new List <string> (); AppendResults(temp, partial_name, results); results = temp; } throw new CompletionResult(partial_name == null ? "" : partial_name, results.Distinct().ToArray()); }
// // Factory method: if there are pending implementation methods, we return a PendingImplementation // object, otherwise we return null. // // Register method implementations are either abstract methods // flagged as such on the base class or interface methods // static public PendingImplementation GetPendingImplementations(TypeContainer container) { TypeSpec b = container.BaseType; var missing_interfaces = GetMissingInterfaces(container); // // If we are implementing an abstract class, and we are not // ourselves abstract, and there are abstract methods (C# allows // abstract classes that have no abstract methods), then allocate // one slot. // // We also pre-compute the methods. // bool implementing_abstract = ((b != null) && b.IsAbstract && (container.ModFlags & Modifiers.ABSTRACT) == 0); MethodSpec[] abstract_methods = null; if (implementing_abstract) { var am = MemberCache.GetNotImplementedAbstractMethods(b); if (am == null) { implementing_abstract = false; } else { abstract_methods = new MethodSpec[am.Count]; am.CopyTo(abstract_methods, 0); } } int total = missing_interfaces.Length + (implementing_abstract ? 1 : 0); if (total == 0) { return(null); } return(new PendingImplementation(container, missing_interfaces, abstract_methods, total)); }
internal static FieldInfo GetField(Type type, string name, BindingFlags bindingAttr) { if (SkipCache) { return(GetFieldInfo(type, name, bindingAttr)); } FieldInfo result = null; MemberCache memberCache = GetMemberCache(type); Tuple <string, int> key = MakeTuple(name, bindingAttr); if (!memberCache.Fields.TryGetValue(key, out result)) { result = GetFieldInfo(type, name, bindingAttr); memberCache.Fields.TryAdd(key, result); } return(result); }
public IDictionary <string, IMemberAttribute> ReflectMembers(string typeFullName, out string defaultTableName) { //string typeFullName = entity.Implement; if (string.IsNullOrEmpty(typeFullName)) { throw new ArgumentNullException("typeFullName"); } Type type = Type.GetType(typeFullName, true); defaultTableName = type.Name; PropertyInfo[] propertyInfos = type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic); //the interface Type itf = type.GetInterface("IAlbianObject"); //get the signature interface PropertyInfo idInfo = itf.GetProperty("Id"); PropertyInfo isNewInfo = itf.GetProperty("IsNew"); if (null == propertyInfos || 0 == propertyInfos.Length) { throw new Exception(string.Format("Reflect the {0} property is error.", typeFullName)); } IDictionary <string, IMemberAttribute> memberAttributes = new Dictionary <string, IMemberAttribute>(); foreach (PropertyInfo propertyInfo in propertyInfos) { IMemberAttribute memberAttribute = ReflectProperty(propertyInfo, idInfo, isNewInfo); memberAttributes.Add(memberAttribute.Name, memberAttribute); } if (0 == memberAttributes.Count) { return(null); } PropertyCache.InsertOrUpdate(typeFullName, propertyInfos); //just only have property MemberCache.InsertOrUpdate(typeFullName, memberAttributes); //parser object by member attributes return(memberAttributes); }
public FieldSpec Mutate(TypeParameterMutator mutator) { var decl = DeclaringType; if (DeclaringType.IsGenericOrParentIsGeneric) { decl = mutator.Mutate(decl); } if (decl == DeclaringType) { return(this); } var fs = (FieldSpec)MemberwiseClone(); fs.declaringType = decl; fs.state |= StateFlags.PendingMetaInflate; // Gets back FieldInfo in case of metaInfo was inflated fs.metaInfo = MemberCache.GetMember(TypeParameterMutator.GetMemberDeclaringType(DeclaringType), this).metaInfo; return(fs); }
// // Return container with awaiter definition. It never returns null // but all container member can be null for easier error reporting // public AwaiterDefinition GetAwaiter(TypeSpec type) { AwaiterDefinition awaiter; if (awaiters.TryGetValue(type, out awaiter)) { return(awaiter); } awaiter = new AwaiterDefinition(); // // Predefined: bool IsCompleted { get; } // awaiter.IsCompleted = MemberCache.FindMember(type, MemberFilter.Property("IsCompleted", Compiler.BuiltinTypes.Bool), BindingRestriction.InstanceOnly) as PropertySpec; // // Predefined: GetResult () // // The method return type is also result type of await expression // awaiter.GetResult = MemberCache.FindMember(type, MemberFilter.Method("GetResult", 0, ParametersCompiled.EmptyReadOnlyParameters, null), BindingRestriction.InstanceOnly) as MethodSpec; // // Predefined: INotifyCompletion.OnCompleted (System.Action) // var nc = PredefinedTypes.INotifyCompletion; awaiter.INotifyCompletion = !nc.Define() || type.ImplementsInterface(nc.TypeSpec, false); awaiters.Add(type, awaiter); return(awaiter); }
/// <summary> /// This function tells whether one of our base classes implements /// the given method (which turns out, it is valid to have an interface /// implementation in a base /// </summary> bool BaseImplements(TypeSpec iface_type, MethodSpec mi, out MethodSpec base_method) { var base_type = container.BaseType; // // Setup filter with no return type to give better error message // about mismatch at return type when the check bellow rejects them // var filter = new MemberFilter(mi.Name, mi.Arity, MemberKind.Method, mi.Parameters, null); base_method = (MethodSpec)MemberCache.FindMember(base_type, filter, BindingRestriction.None); if (base_method == null || (base_method.Modifiers & Modifiers.PUBLIC) == 0) { return(false); } if (base_method.DeclaringType.IsInterface) { return(false); } if (!TypeSpecComparer.Override.IsEqual(mi.ReturnType, base_method.ReturnType)) { return(false); } if (!base_method.IsAbstract && !base_method.IsVirtual) { // FIXME: We can avoid creating a proxy if base_method can be marked 'final virtual' instead. // However, it's too late now, the MethodBuilder has already been created (see bug 377519) DefineProxy(iface_type, base_method, mi); } return(true); }
public MemberSpec FindElement(IMemberContext mc, string name, Location loc) { // TODO: cache it for (int i = 0; i < elements.Count; ++i) { var ename = elements [i]; if (ename == null || ename != name) { continue; } var member_name = GetElementPropertyName(i); var ms = MemberCache.FindMember(tuple, MemberFilter.Field(member_name, null), BindingRestriction.DeclaredOnly | BindingRestriction.InstanceOnly); if (ms == null) { mc.Module.Compiler.Report.Error(8128, loc, "Member `{0}' was not found on type '{1}'", member_name, tuple.GetSignatureForError()); return(null); } return(ms); } return(null); }
public override void Emit(EmitContext ec) { // // Load Iterator storey instance // IteratorHost.Instance.Emit(ec); // // Initialize iterator PC when it's unitialized // if (IsEnumerable) { ec.Emit(OpCodes.Dup); ec.EmitInt((int)State.Uninitialized); var field = IteratorHost.PC.Spec; if (Storey.MemberName.IsGeneric) { field = MemberCache.GetMember(Storey.Instance.Type, field); } ec.Emit(OpCodes.Stfld, field); } }
private void pushButton_Click(object sender, EventArgs e) { string LocalFile; List <string> Commands = new List <string>(); Dictionary <string, string> PushList = new Dictionary <string, string>(); string[] Path; if (runCommands.Checked) { foreach (var Member in CreateSPFs) { Commands.Add("CRTSRCPF FILE(" + lib.Text.Trim() + "/" + Member.Key + ") RCDLEN(" + Member.Value.ToString() + ")"); } foreach (string Member in DeleteMembers) { Path = Member.Split('/'); Commands.Add("RMVM FILE(" + lib.Text.Trim() + "/" + Path[0] + ") MBR(" + Path[1] + ")"); } foreach (var Member in CreateMembers) { Path = Member.Key.Trim().Split('/'); Commands.Add("ADDPFM FILE(" + lib.Text.Trim() + "/" + Path[0] + ") MBR(" + Path[1] + ") SRCTYPE(" + Member.Value.Trim() + ")"); } } foreach (ListViewItem Member in memberLog.Items) { if (Member.Checked) { Path = Member.Text.Trim().Split('/'); LocalFile = IBMiUtils.GetLocalFile(lib.Text.Trim(), Path[0], Path[1], UploadMembers[Path[0] + '/' + Path[1]]); PushList.Add(LocalFile, "/QSYS.lib/" + lib.Text.Trim() + ".lib/" + Path[0] + ".file/" + Path[1] + ".mbr"); } } Boolean Success = IBMi.RunCommands(Commands.ToArray()); if (Success) { foreach (var File in PushList) { if (IBMi.UploadFile(File.Key, File.Value) == false) { Success = false; } } if (Success) { MessageBox.Show("Push to server was successful."); MemberCache.EditsClear(); this.Close(); } else { MessageBox.Show("Push to server was not successful (stage 2)"); } } else { MessageBox.Show("Push to server was not successful (stage 1)"); } }
// // Processes "see" or "seealso" elements from cref attribute. // void HandleXrefCommon(MemberCore mc, 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 NamespaceExpression; 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); }
private void Editor_FormClosing(object sender, FormClosingEventArgs e) { MemberCache.Export(); }
protected override bool DoDefineMembers() { if (IsGeneric) { foreach (TypeParameter type_param in TypeParameters) { if (!type_param.Resolve(this)) { return(false); } } foreach (TypeParameter type_param in TypeParameters) { if (!type_param.DefineType(this)) { return(false); } } } member_cache = new MemberCache(TypeManager.multicast_delegate_type, this); // FIXME: POSSIBLY make this static, as it is always constant // Type [] const_arg_types = new Type [2]; const_arg_types [0] = TypeManager.object_type; const_arg_types [1] = TypeManager.intptr_type; const MethodAttributes ctor_mattr = MethodAttributes.RTSpecialName | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Public; ConstructorBuilder = TypeBuilder.DefineConstructor(ctor_mattr, CallingConventions.Standard, const_arg_types); ConstructorBuilder.DefineParameter(1, ParameterAttributes.None, "object"); ConstructorBuilder.DefineParameter(2, ParameterAttributes.None, "method"); // // HACK because System.Reflection.Emit is lame // IParameterData [] fixed_pars = new IParameterData [] { new ParameterData("object", Parameter.Modifier.NONE), new ParameterData("method", Parameter.Modifier.NONE) }; AParametersCollection const_parameters = new ParametersImported( fixed_pars, new Type[] { TypeManager.object_type, TypeManager.intptr_type }); TypeManager.RegisterMethod(ConstructorBuilder, const_parameters); member_cache.AddMember(ConstructorBuilder, this); ConstructorBuilder.SetImplementationFlags(MethodImplAttributes.Runtime); // // 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: if (!Parameters.Resolve(this)) { return(false); } // // Invoke method // // Check accessibility foreach (Type partype in Parameters.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()); return(false); } } ReturnType = ReturnType.ResolveAsTypeTerminal(this, false); if (ReturnType == null) { return(false); } ret_type = ReturnType.Type; 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 (RootContext.StdLib && TypeManager.IsSpecialType(ret_type)) { Method.Error1599(Location, ret_type, Report); return(false); } TypeManager.CheckTypeVariance(ret_type, Variance.Covariant, this); // // We don't have to check any others because they are all // guaranteed to be accessible - they are standard types. // CallingConventions cc = Parameters.CallingConvention; InvokeBuilder = TypeBuilder.DefineMethod("Invoke", mattr, cc, ret_type, Parameters.GetEmitTypes()); InvokeBuilder.SetImplementationFlags(MethodImplAttributes.Runtime); TypeManager.RegisterMethod(InvokeBuilder, Parameters); member_cache.AddMember(InvokeBuilder, this); // // Don't emit async method for compiler generated delegates (e.g. dynamic site containers) // if (TypeManager.iasyncresult_type != null && TypeManager.asynccallback_type != null && !IsCompilerGenerated) { DefineAsyncMethods(cc); } return(true); }
// // Don't use unless really required for correctness, see Unwrap::Emit // public static MethodSpec GetValue(TypeSpec nullableType) { return((MethodSpec)MemberCache.FindMember(nullableType, MemberFilter.Method("get_Value", 0, ParametersCompiled.EmptyReadOnlyParameters, null), BindingRestriction.None)); }
public static MethodSpec GetConstructor(TypeSpec delType) { var ctor = MemberCache.FindMember(delType, MemberFilter.Constructor(null), BindingRestriction.DeclaredOnly); return((MethodSpec)ctor); }
// // Factory method: if there are pending implementation methods, we return a PendingImplementation // object, otherwise we return null. // // Register method implementations are either abstract methods // flagged as such on the base class or interface methods // static public PendingImplementation GetPendingImplementations(TypeDefinition container) { TypeSpec b = container.BaseType; var missing_interfaces = GetMissingInterfaces(container); // // If we are implementing an abstract class, and we are not // ourselves abstract, and there are abstract methods (C# allows // abstract classes that have no abstract methods), then allocate // one slot. // // We also pre-compute the methods. // bool implementing_abstract = ((b != null) && b.IsAbstract && (container.ModFlags & Modifiers.ABSTRACT) == 0); MethodSpec[] abstract_methods = null; if (implementing_abstract) { var am = MemberCache.GetNotImplementedAbstractMethods(b); if (am == null) { implementing_abstract = false; } else { abstract_methods = new MethodSpec[am.Count]; am.CopyTo(abstract_methods, 0); } } int total = missing_interfaces.Length + (implementing_abstract ? 1 : 0); if (total == 0) { return(null); } var pending = new PendingImplementation(container, missing_interfaces, abstract_methods, total); // // check for inherited conflicting methods // foreach (var p in pending.pending_implementations) { // // It can happen for generic interfaces only // if (!p.type.IsGeneric) { continue; } // // CLR does not distinguishes between ref and out // for (int i = 0; i < p.methods.Count; ++i) { MethodSpec compared_method = p.methods[i]; if (compared_method.Parameters.IsEmpty) { continue; } for (int ii = i + 1; ii < p.methods.Count; ++ii) { MethodSpec tested_method = p.methods[ii]; if (compared_method.Name != tested_method.Name) { continue; } if (p.type != tested_method.DeclaringType) { continue; } if (!TypeSpecComparer.Override.IsSame(compared_method.Parameters.Types, tested_method.Parameters.Types)) { continue; } bool exact_match = true; bool ref_only_difference = false; var cp = compared_method.Parameters.FixedParameters; var tp = tested_method.Parameters.FixedParameters; for (int pi = 0; pi < cp.Length; ++pi) { // // First check exact modifiers match // if ((cp[pi].ModFlags & Parameter.Modifier.RefOutMask) == (tp[pi].ModFlags & Parameter.Modifier.RefOutMask)) { continue; } if (((cp[pi].ModFlags | tp[pi].ModFlags) & Parameter.Modifier.RefOutMask) == Parameter.Modifier.RefOutMask) { ref_only_difference = true; continue; } exact_match = false; break; } if (!exact_match || !ref_only_difference) { continue; } pending.Report.SymbolRelatedToPreviousError(compared_method); pending.Report.SymbolRelatedToPreviousError(tested_method); pending.Report.Error(767, container.Location, "Cannot implement interface `{0}' with the specified type parameters because it causes method `{1}' to differ on parameter modifiers only", p.type.GetDefinition().GetSignatureForError(), compared_method.GetSignatureForError()); break; } } } return(pending); }
public void EmitInitializer(EmitContext ec) { // // Some predefined types are missing // if (builder == null) { return; } var instance = (TemporaryVariableReference)Instance; var builder_field = builder.Spec; if (MemberName.Arity > 0) { builder_field = MemberCache.GetMember(instance.Type, builder_field); } // // Inflated factory method when task is of generic type // if (builder_factory.DeclaringType.IsGeneric) { var task_return_type = return_type.TypeArguments; var bt = builder_factory.DeclaringType.MakeGenericType(Module, task_return_type); builder_factory = MemberCache.GetMember(bt, builder_factory); builder_start = MemberCache.GetMember(bt, builder_start); } // // stateMachine.$builder = AsyncTaskMethodBuilder<{task-type}>.Create(); // instance.AddressOf(ec, AddressOp.Store); ec.Emit(OpCodes.Call, builder_factory); ec.Emit(OpCodes.Stfld, builder_field); // // stateMachine.$builder.Start<{storey-type}>(ref stateMachine); // instance.AddressOf(ec, AddressOp.Store); ec.Emit(OpCodes.Ldflda, builder_field); if (Task != null) { ec.Emit(OpCodes.Dup); } instance.AddressOf(ec, AddressOp.Store); ec.Emit(OpCodes.Call, builder_start.MakeGenericMethod(Module, instance.Type)); // // Emits return stateMachine.$builder.Task; // if (Task != null) { var task_get = Task.Get; if (MemberName.Arity > 0) { task_get = MemberCache.GetMember(builder_field.MemberType, task_get); } var pe_task = new PropertyExpr(Task, Location) { InstanceExpression = EmptyExpression.Null, // Comes from the dup above Getter = task_get }; pe_task.Emit(ec); } }
public void LoadMembers (TypeSpec declaringType, bool onlyTypes, ref MemberCache cache) { throw new NotImplementedException (); }
private void fetch_Click(object sender, EventArgs e) { string LocalLIB = IBMiUtils.GetLocalDir(lib.Text); string[] Dirs = Directory.GetDirectories(LocalLIB), MbrPath; string Name, Ext, LocalMember, SPF; bool CheckedUpload = false; foreach (string Dir in Dirs) { SPF = Path.GetFileName(Dir); Member[] MemberList = IBMiUtils.GetMemberList(lib.Text, SPF); if (MemberList == null) { CreateSPFs.Add(SPF, 112); } foreach (string FilePath in Directory.GetFiles(Dir)) { Name = SPF + '/' + Path.GetFileNameWithoutExtension(FilePath); Ext = Path.GetExtension(FilePath).TrimStart('.'); if (MemberList == null) { CreateMembers.Add(Name, Ext); } else { if (MemberList.Where(x => (x.GetObject() + '/' + x.GetMember()) == Name).Count() == 0) { CreateMembers.Add(Name, Ext); } } UploadMembers.Add(Name, Ext); } if (MemberList != null) { foreach (Member MemberInfo in MemberList) { LocalMember = IBMiUtils.GetLocalFile(MemberInfo.GetLibrary(), MemberInfo.GetObject(), MemberInfo.GetMember(), MemberInfo.GetExtension()); if (!File.Exists(LocalMember)) { DeleteMembers.Add(MemberInfo.GetObject() + "/" + MemberInfo.GetMember()); } } } } foreach (var SPFInfo in CreateSPFs) { commandLog.Items.Add(new ListViewItem(SPFInfo.Key + " (" + SPFInfo.Value.ToString() + ")", commandLog.Groups[0])); } foreach (string MemberName in DeleteMembers) { commandLog.Items.Add(new ListViewItem(MemberName, commandLog.Groups[1])); } foreach (var MemberInfo in CreateMembers) { commandLog.Items.Add(new ListViewItem(MemberInfo.Key + "." + MemberInfo.Value, commandLog.Groups[2])); } foreach (var MemberName in UploadMembers) { MbrPath = MemberName.Key.Trim().Split('/'); CheckedUpload = MemberCache.EditsContains(lib.Text.ToUpper(), MbrPath[0], MbrPath[1]); memberLog.Items.Add(new ListViewItem(MemberName.Key) { Checked = CheckedUpload }); } pushButton.Enabled = true; fetch.Enabled = false; lib.Enabled = false; runCommands.Enabled = true; }
protected void EmitCall(EmitContext ec, Expression binder, Arguments arguments, bool isStatement) { // // This method generates all internal infrastructure for a dynamic call. The // reason why it's quite complicated is the mixture of dynamic and anonymous // methods. Dynamic itself requires a temporary class (ContainerX) and anonymous // methods can generate temporary storey as well (AnonStorey). Handling MVAR // type parameters rewrite is non-trivial in such case as there are various // combinations possible therefore the mutator is not straightforward. Secondly // we need to keep both MVAR(possibly VAR for anon storey) and type VAR to emit // correct Site field type and its access from EmitContext. // int dyn_args_count = arguments == null ? 0 : arguments.Count; int default_args = isStatement ? 1 : 2; var module = ec.Module; bool has_ref_out_argument = false; var targs = new TypeExpression[dyn_args_count + default_args]; targs[0] = new TypeExpression(module.PredefinedTypes.CallSite.TypeSpec, loc); TypeExpression[] targs_for_instance = null; TypeParameterMutator mutator; var site_container = ec.CreateDynamicSite(); if (context_mvars != null) { TypeParameters tparam; TypeContainer sc = site_container; do { tparam = sc.CurrentTypeParameters; sc = sc.Parent; } while (tparam == null); mutator = new TypeParameterMutator(context_mvars, tparam); if (!ec.IsAnonymousStoreyMutateRequired) { targs_for_instance = new TypeExpression[targs.Length]; targs_for_instance[0] = targs[0]; } } else { mutator = null; } for (int i = 0; i < dyn_args_count; ++i) { Argument a = arguments[i]; if (a.ArgType == Argument.AType.Out || a.ArgType == Argument.AType.Ref) { has_ref_out_argument = true; } var t = a.Type; // Convert any internal type like dynamic or null to object if (t.Kind == MemberKind.InternalCompilerType) { t = ec.BuiltinTypes.Object; } if (targs_for_instance != null) { targs_for_instance[i + 1] = new TypeExpression(t, loc); } if (mutator != null) { t = t.Mutate(mutator); } targs[i + 1] = new TypeExpression(t, loc); } TypeExpr del_type = null; TypeExpr del_type_instance_access = null; if (!has_ref_out_argument) { string d_name = isStatement ? "Action" : "Func"; TypeSpec te = null; Namespace type_ns = module.GlobalRootNamespace.GetNamespace("System", true); if (type_ns != null) { te = type_ns.LookupType(module, d_name, dyn_args_count + default_args, LookupMode.Normal, loc); } if (te != null) { if (!isStatement) { var t = type; if (t.Kind == MemberKind.InternalCompilerType) { t = ec.BuiltinTypes.Object; } if (targs_for_instance != null) { targs_for_instance[targs_for_instance.Length - 1] = new TypeExpression(t, loc); } if (mutator != null) { t = t.Mutate(mutator); } targs[targs.Length - 1] = new TypeExpression(t, loc); } del_type = new GenericTypeExpr(te, new TypeArguments(targs), loc); if (targs_for_instance != null) { del_type_instance_access = new GenericTypeExpr(te, new TypeArguments(targs_for_instance), loc); } else { del_type_instance_access = del_type; } } } // // Create custom delegate when no appropriate predefined delegate has been found // Delegate d; if (del_type == null) { TypeSpec rt = isStatement ? ec.BuiltinTypes.Void : type; Parameter[] p = new Parameter[dyn_args_count + 1]; p[0] = new Parameter(targs[0], "p0", Parameter.Modifier.NONE, null, loc); var site = ec.CreateDynamicSite(); int index = site.Containers == null ? 0 : site.Containers.Count; if (mutator != null) { rt = mutator.Mutate(rt); } for (int i = 1; i < dyn_args_count + 1; ++i) { p[i] = new Parameter(targs[i], "p" + i.ToString("X"), arguments[i - 1].Modifier, null, loc); } d = new Delegate(site, new TypeExpression(rt, loc), Modifiers.INTERNAL | Modifiers.COMPILER_GENERATED, new MemberName("Container" + index.ToString("X")), new ParametersCompiled(p), null); d.CreateContainer(); d.DefineContainer(); d.Define(); d.PrepareEmit(); site.AddTypeContainer(d); // // Add new container to inflated site container when the // member cache already exists // if (site.CurrentType is InflatedTypeSpec && index > 0) { site.CurrentType.MemberCache.AddMember(d.CurrentType); } del_type = new TypeExpression(d.CurrentType, loc); if (targs_for_instance != null) { del_type_instance_access = null; } else { del_type_instance_access = del_type; } } else { d = null; } var site_type_decl = new GenericTypeExpr(module.PredefinedTypes.CallSiteGeneric.TypeSpec, new TypeArguments(del_type), loc); var field = site_container.CreateCallSiteField(site_type_decl, loc); if (field == null) { return; } if (del_type_instance_access == null) { var dt = d.CurrentType.DeclaringType.MakeGenericType(module, context_mvars.Types); del_type_instance_access = new TypeExpression(MemberCache.GetMember(dt, d.CurrentType), loc); } var instanceAccessExprType = new GenericTypeExpr(module.PredefinedTypes.CallSiteGeneric.TypeSpec, new TypeArguments(del_type_instance_access), loc); if (instanceAccessExprType.ResolveAsType(ec.MemberContext) == null) { return; } bool inflate_using_mvar = context_mvars != null && ec.IsAnonymousStoreyMutateRequired; TypeSpec gt; if (inflate_using_mvar || context_mvars == null) { gt = site_container.CurrentType; } else { gt = site_container.CurrentType.MakeGenericType(module, context_mvars.Types); } // When site container already exists the inflated version has to be // updated manually to contain newly created field if (gt is InflatedTypeSpec && site_container.AnonymousMethodsCounter > 1) { var tparams = gt.MemberDefinition.TypeParametersCount > 0 ? gt.MemberDefinition.TypeParameters : TypeParameterSpec.EmptyTypes; var inflator = new TypeParameterInflator(module, gt, tparams, gt.TypeArguments); gt.MemberCache.AddMember(field.InflateMember(inflator)); } FieldExpr site_field_expr = new FieldExpr(MemberCache.GetMember(gt, field), loc); BlockContext bc = new BlockContext(ec.MemberContext, null, ec.BuiltinTypes.Void); Arguments args = new Arguments(1); args.Add(new Argument(binder)); StatementExpression s = new StatementExpression(new SimpleAssign(site_field_expr, new Invocation(new MemberAccess(instanceAccessExprType, "Create"), args))); using (ec.With(BuilderContext.Options.OmitDebugInfo, true)) { if (s.Resolve(bc)) { Statement init = new If(new Binary(Binary.Operator.Equality, site_field_expr, new NullLiteral(loc)), s, loc); init.Emit(ec); } args = new Arguments(1 + dyn_args_count); args.Add(new Argument(site_field_expr)); if (arguments != null) { int arg_pos = 1; foreach (Argument a in arguments) { if (a is NamedArgument) { // Name is not valid in this context args.Add(new Argument(a.Expr, a.ArgType)); } else { args.Add(a); } if (inflate_using_mvar && a.Type != targs[arg_pos].Type) { a.Expr.Type = targs[arg_pos].Type; } ++arg_pos; } } Expression target = new DelegateInvocation(new MemberAccess(site_field_expr, "Target", loc).Resolve(bc), args, loc).Resolve(bc); if (target != null) { target.Emit(ec); } } }
public void LoadMembers (TypeSpec declaringType, bool onlyTypes, ref MemberCache cache) { // // Not interested in members of nested private types unless the importer needs them // if (declaringType.IsPrivate && importer.IgnorePrivateMembers) { cache = MemberCache.Empty; return; } var loading_type = (MetaType) provider; const BindingFlags all_members = BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic; const MethodAttributes explicit_impl = MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.Final; Dictionary<MethodBase, MethodSpec> possible_accessors = null; List<EventSpec> imported_events = null; EventSpec event_spec; MemberSpec imported; MethodInfo m; MemberInfo[] all; try { all = loading_type.GetMembers (all_members); } catch (Exception e) { throw new InternalErrorException (e, "Could not import type `{0}' from `{1}'", declaringType.GetSignatureForError (), declaringType.MemberDefinition.DeclaringAssembly.FullName); } if (cache == null) { cache = new MemberCache (all.Length); // // Do the types first as they can be referenced by the members before // they are found or inflated // foreach (var member in all) { if (member.MemberType != MemberTypes.NestedType) continue; var t = (MetaType) member; // Ignore compiler generated types, mostly lambda containers if ((t.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPrivate && importer.IgnorePrivateMembers) continue; try { imported = importer.CreateNestedType (t, declaringType); } catch (Exception e) { throw new InternalErrorException (e, "Could not import nested type `{0}' from `{1}'", t.FullName, declaringType.MemberDefinition.DeclaringAssembly.FullName); } cache.AddMemberImported (imported); } foreach (var member in all) { if (member.MemberType != MemberTypes.NestedType) continue; var t = (MetaType) member; if ((t.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPrivate && importer.IgnorePrivateMembers) continue; importer.ImportTypeBase (t); } } // // Load base interfaces first to minic behaviour of compiled members // if (declaringType.IsInterface && declaringType.Interfaces != null) { foreach (var iface in declaringType.Interfaces) { cache.AddInterface (iface); } } if (!onlyTypes) { // // The logic here requires methods to be returned first which seems to work for both Mono and .NET // foreach (var member in all) { switch (member.MemberType) { case MemberTypes.Constructor: if (declaringType.IsInterface) continue; goto case MemberTypes.Method; case MemberTypes.Method: MethodBase mb = (MethodBase) member; var attrs = mb.Attributes; if ((attrs & MethodAttributes.MemberAccessMask) == MethodAttributes.Private) { if (importer.IgnorePrivateMembers) continue; // Ignore explicitly implemented members if ((attrs & explicit_impl) == explicit_impl) continue; // Ignore compiler generated methods if (MetadataImporter.HasAttribute (CustomAttributeData.GetCustomAttributes (mb), "CompilerGeneratedAttribute", MetadataImporter.CompilerServicesNamespace)) continue; } imported = importer.CreateMethod (mb, declaringType); if (imported.Kind == MemberKind.Method && !imported.IsGeneric) { if (possible_accessors == null) possible_accessors = new Dictionary<MethodBase, MethodSpec> (ReferenceEquality<MethodBase>.Default); // There are no metadata rules for accessors, we have to consider any method as possible candidate possible_accessors.Add (mb, (MethodSpec) imported); } break; case MemberTypes.Property: if (possible_accessors == null) continue; var p = (PropertyInfo) member; // // Links possible accessors with property // MethodSpec get, set; m = p.GetGetMethod (true); if (m == null || !possible_accessors.TryGetValue (m, out get)) get = null; m = p.GetSetMethod (true); if (m == null || !possible_accessors.TryGetValue (m, out set)) set = null; // No accessors registered (e.g. explicit implementation) if (get == null && set == null) continue; try { imported = importer.CreateProperty (p, declaringType, get, set); } catch (Exception ex) { throw new InternalErrorException (ex, "Could not import property `{0}' inside `{1}'", p.Name, declaringType.GetSignatureForError ()); } if (imported == null) continue; break; case MemberTypes.Event: if (possible_accessors == null) continue; var e = (EventInfo) member; // // Links accessors with event // MethodSpec add, remove; m = e.GetAddMethod (true); if (m == null || !possible_accessors.TryGetValue (m, out add)) add = null; m = e.GetRemoveMethod (true); if (m == null || !possible_accessors.TryGetValue (m, out remove)) remove = null; // Both accessors are required if (add == null || remove == null) continue; event_spec = importer.CreateEvent (e, declaringType, add, remove); if (!importer.IgnorePrivateMembers) { if (imported_events == null) imported_events = new List<EventSpec> (); imported_events.Add (event_spec); } imported = event_spec; break; case MemberTypes.Field: var fi = (FieldInfo) member; imported = importer.CreateField (fi, declaringType); if (imported == null) continue; // // For dynamic binder event has to be fully restored to allow operations // within the type container to work correctly // if (imported_events != null) { // The backing event field should be private but it may not int i; for (i = 0; i < imported_events.Count; ++i) { var ev = imported_events[i]; if (ev.Name == fi.Name) { ev.BackingField = (FieldSpec) imported; imported_events.RemoveAt (i); i = -1; break; } } if (i < 0) continue; } break; case MemberTypes.NestedType: // Already in the cache from the first pass continue; default: throw new NotImplementedException (member.ToString ()); } if (imported.IsStatic && declaringType.IsInterface) continue; cache.AddMemberImported (imported); } } }
public static MethodSpec GetConstructor(TypeSpec nullableType) { return((MethodSpec)MemberCache.FindMember(nullableType, MemberFilter.Constructor(ParametersCompiled.CreateFullyResolved(GetUnderlyingType(nullableType))), BindingRestriction.DeclaredOnly)); }
public override bool Define() { member_cache = new MemberCache(TypeManager.enum_type, this); DefineContainerMembers(constants); return(true); }
protected override bool DoDefineMembers() { PredefinedType builder_type; PredefinedMember <MethodSpec> bf; PredefinedMember <MethodSpec> bs; PredefinedMember <MethodSpec> sr; PredefinedMember <MethodSpec> se; PredefinedMember <MethodSpec> sm; bool has_task_return_type = false; var pred_members = Module.PredefinedMembers; if (return_type.Kind == MemberKind.Void) { builder_type = Module.PredefinedTypes.AsyncVoidMethodBuilder; bf = pred_members.AsyncVoidMethodBuilderCreate; bs = pred_members.AsyncVoidMethodBuilderStart; sr = pred_members.AsyncVoidMethodBuilderSetResult; se = pred_members.AsyncVoidMethodBuilderSetException; sm = pred_members.AsyncVoidMethodBuilderSetStateMachine; } else if (return_type == Module.PredefinedTypes.Task.TypeSpec) { builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilder; bf = pred_members.AsyncTaskMethodBuilderCreate; bs = pred_members.AsyncTaskMethodBuilderStart; sr = pred_members.AsyncTaskMethodBuilderSetResult; se = pred_members.AsyncTaskMethodBuilderSetException; sm = pred_members.AsyncTaskMethodBuilderSetStateMachine; task = pred_members.AsyncTaskMethodBuilderTask.Get(); } else { builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilderGeneric; bf = pred_members.AsyncTaskMethodBuilderGenericCreate; bs = pred_members.AsyncTaskMethodBuilderGenericStart; sr = pred_members.AsyncTaskMethodBuilderGenericSetResult; se = pred_members.AsyncTaskMethodBuilderGenericSetException; sm = pred_members.AsyncTaskMethodBuilderGenericSetStateMachine; task = pred_members.AsyncTaskMethodBuilderGenericTask.Get(); has_task_return_type = true; } set_result = sr.Get(); set_exception = se.Get(); builder_factory = bf.Get(); builder_start = bs.Get(); var istate_machine = Module.PredefinedTypes.IAsyncStateMachine; var set_statemachine = sm.Get(); if (!builder_type.Define() || !istate_machine.Define() || set_result == null || builder_factory == null || set_exception == null || set_statemachine == null || builder_start == null || !Module.PredefinedTypes.INotifyCompletion.Define()) { Report.Error(1993, Location, "Cannot find compiler required types for asynchronous functions support. Are you targeting the wrong framework version?"); return(base.DoDefineMembers()); } var bt = builder_type.TypeSpec; // // Inflate generic Task types // if (has_task_return_type) { var task_return_type = return_type.TypeArguments; if (mutator != null) { task_return_type = mutator.Mutate(task_return_type); } bt = bt.MakeGenericType(Module, task_return_type); set_result = MemberCache.GetMember(bt, set_result); set_exception = MemberCache.GetMember(bt, set_exception); set_statemachine = MemberCache.GetMember(bt, set_statemachine); if (task != null) { task = MemberCache.GetMember(bt, task); } } builder = AddCompilerGeneratedField("$builder", new TypeExpression(bt, Location)); var set_state_machine = new Method(this, new TypeExpression(Compiler.BuiltinTypes.Void, Location), Modifiers.COMPILER_GENERATED | Modifiers.DEBUGGER_HIDDEN | Modifiers.PUBLIC, new MemberName("SetStateMachine"), ParametersCompiled.CreateFullyResolved( new Parameter(new TypeExpression(istate_machine.TypeSpec, Location), "stateMachine", Parameter.Modifier.NONE, null, Location), istate_machine.TypeSpec), null); ToplevelBlock block = new ToplevelBlock(Compiler, set_state_machine.ParameterInfo, Location); block.IsCompilerGenerated = true; set_state_machine.Block = block; Members.Add(set_state_machine); if (!base.DoDefineMembers()) { return(false); } // // Fabricates SetStateMachine method // // public void SetStateMachine (IAsyncStateMachine stateMachine) // { // $builder.SetStateMachine (stateMachine); // } // var mg = MethodGroupExpr.CreatePredefined(set_statemachine, bt, Location); mg.InstanceExpression = new FieldExpr(builder, Location); var param_reference = block.GetParameterReference(0, Location); param_reference.Type = istate_machine.TypeSpec; param_reference.eclass = ExprClass.Variable; var args = new Arguments(1); args.Add(new Argument(param_reference)); set_state_machine.Block.AddStatement(new StatementExpression(new Invocation(mg, args))); if (has_task_return_type) { HoistedReturnValue = TemporaryVariableReference.Create(bt.TypeArguments [0], StateMachineMethod.Block, Location); } return(true); }
public void Save() { RemoteSource SourceInfo = (RemoteSource)this.Tag; bool UploadResult = true; if (SourceInfo != null) { if (SourceInfo.IsEditable()) { if (!SourceInfo._IsBeingSaved) { SourceInfo._IsBeingSaved = true; Editor.TheEditor.SetStatus("Saving " + SourceInfo.GetName() + ".."); Thread gothread = new Thread((ThreadStart) delegate { MemberCache.EditsAdd(SourceInfo.GetLibrary(), SourceInfo.GetObject(), SourceInfo.GetName()); this.Invoke((MethodInvoker) delegate { File.WriteAllText(SourceInfo.GetLocalFile(), this.GetText(), textEditor.Encoding); }); switch (SourceInfo.GetFS()) { case FileSystem.QSYS: UploadResult = IBMiUtils.UploadMember(SourceInfo.GetLocalFile(), SourceInfo.GetLibrary(), SourceInfo.GetObject(), SourceInfo.GetName()); break; case FileSystem.IFS: UploadResult = IBMiUtils.UploadFile(SourceInfo.GetLocalFile(), SourceInfo.GetRemoteFile()); break; } if (UploadResult == false) { } else { this.Invoke((MethodInvoker) delegate { if (GetParent().Text.EndsWith("*")) { GetParent().Text = GetParent().Text.Substring(0, GetParent().Text.Length - 1); } }); } this.Invoke((MethodInvoker) delegate { Editor.TheEditor.SetStatus(SourceInfo.GetName() + " " + (UploadResult ? "" : "not ") + "saved."); }); SourceInfo._IsBeingSaved = false; }); gothread.Start(); } } else { MessageBox.Show("This file is readonly."); } } else { File.WriteAllText(this.LocalPath, this.GetText(), textEditor.Encoding); if (GetParent().Text.EndsWith("*")) { GetParent().Text = GetParent().Text.Substring(0, GetParent().Text.Length - 1); } Editor.TheEditor.SetStatus("File saved locally."); } }
public void LoadMembers (TypeSpec declaringType, bool onlyTypes, ref MemberCache cache) { throw new NotSupportedException ("Not supported for compiled definition " + GetSignatureForError ()); }
private static MemberSpec FindDocumentedMemberNoNest( MemberCore mc, TypeSpec type, string member_name, AParametersCollection param_list, DeclSpace ds, out int warning_type, string cref, bool warn419, string name_for_error, Report Report) { warning_type = 0; // var filter = new MemberFilter (member_name, 0, MemberKind.All, param_list, null); IList <MemberSpec> found = null; while (type != null && found == null) { found = MemberCache.FindMembers(type, member_name, false); type = type.DeclaringType; } if (found == null) { return(null); } if (warn419 && found.Count > 1) { Report419(mc, name_for_error, found.ToArray(), Report); } return(found [0]); /* * if (param_list == null) { * // search for fields/events etc. * mis = TypeManager.MemberLookup (type, null, * type, MemberKind.All, * BindingRestriction.None, * 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 * var mi = mis [0]; * TypeSpec expected = mi is MethodSpec ? * ((MethodSpec) mi).ReturnType : * mi is PropertySpec ? * ((PropertySpec) mi).PropertyType : * null; * if (return_type_name != null) { * TypeSpec 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]; */ }
/// <summary> /// This function tells whether one of our base classes implements /// the given method (which turns out, it is valid to have an interface /// implementation in a base /// </summary> bool BaseImplements(TypeSpec iface_type, MethodSpec mi, out MethodSpec base_method) { base_method = null; var base_type = container.BaseType; // // Setup filter with no return type to give better error message // about mismatch at return type when the check bellow rejects them // var parameters = mi.Parameters; MethodSpec close_match = null; while (true) { var candidates = MemberCache.FindMembers(base_type, mi.Name, false); if (candidates == null) { base_method = close_match; return(false); } MethodSpec similar_candidate = null; foreach (var candidate in candidates) { if (candidate.Kind != MemberKind.Method) { continue; } if (candidate.Arity != mi.Arity) { continue; } var candidate_param = ((MethodSpec)candidate).Parameters; if (!TypeSpecComparer.Override.IsEqual(parameters.Types, candidate_param.Types)) { continue; } bool modifiers_match = true; for (int i = 0; i < parameters.Count; ++i) { // // First check exact ref/out match // if ((parameters.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask) == (candidate_param.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask)) { continue; } modifiers_match = false; // // Different in ref/out only // if ((parameters.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask) != (candidate_param.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask)) { if (similar_candidate == null) { if (!candidate.IsPublic) { break; } if (!TypeSpecComparer.Override.IsEqual(mi.ReturnType, ((MethodSpec)candidate).ReturnType)) { break; } // It's used for ref/out ambiguity overload check similar_candidate = (MethodSpec)candidate; } continue; } similar_candidate = null; break; } if (!modifiers_match) { continue; } // // From this point the candidate is used for detailed error reporting // because it's very close match to what we are looking for // var m = (MethodSpec)candidate; if (!m.IsPublic) { if (close_match == null) { close_match = m; } continue; } if (!TypeSpecComparer.Override.IsEqual(mi.ReturnType, m.ReturnType)) { if (close_match == null) { close_match = m; } continue; } base_method = m; if (mi.IsGeneric && !Method.CheckImplementingMethodConstraints(container, m, mi)) { return(true); } } if (base_method != null) { if (similar_candidate != null) { Report.SymbolRelatedToPreviousError(similar_candidate); Report.SymbolRelatedToPreviousError(mi); Report.SymbolRelatedToPreviousError(container); Report.Warning(1956, 1, ((MemberCore)base_method.MemberDefinition).Location, "The interface method `{0}' implementation is ambiguous between following methods: `{1}' and `{2}' in type `{3}'", mi.GetSignatureForError(), base_method.GetSignatureForError(), similar_candidate.GetSignatureForError(), container.GetSignatureForError()); } break; } base_type = candidates[0].DeclaringType.BaseType; if (base_type == null) { base_method = close_match; return(false); } } if (!base_method.IsVirtual) { #if STATIC var base_builder = base_method.GetMetaInfo() as MethodBuilder; if (base_builder != null) { // // We can avoid creating a proxy if base_method can be marked 'final virtual'. This can // be done for all methods from compiled assembly // base_builder.__SetAttributes(base_builder.Attributes | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.NewSlot); return(true); } #endif DefineProxy(iface_type, base_method, mi); } return(true); }
public override bool Resolve(BlockContext bc) { if (bc.CurrentBlock is Linq.QueryBlock) { bc.Report.Error(1995, loc, "The `await' operator may only be used in a query expression within the first collection expression of the initial `from' clause or within the collection expression of a `join' clause"); return(false); } if (!base.Resolve(bc)) { return(false); } Arguments args = new Arguments(0); type = expr.Type; // // The await expression is of dynamic type // if (type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) { result_type = type; expr = new Invocation(new MemberAccess(expr, "GetAwaiter"), args).Resolve(bc); return(true); } // // Check whether the expression is awaitable // Expression ama = new AwaitableMemberAccess(expr).Resolve(bc); if (ama == null) { return(false); } var errors_printer = new SessionReportPrinter(); var old = bc.Report.SetPrinter(errors_printer); ama = new Invocation(ama, args).Resolve(bc); bc.Report.SetPrinter(old); if (errors_printer.ErrorsCount > 0 || !MemberAccess.IsValidDotExpression(ama.Type)) { bc.Report.Error(1986, expr.Location, "The `await' operand type `{0}' must have suitable GetAwaiter method", expr.Type.GetSignatureForError()); return(false); } var awaiter_type = ama.Type; expr = ama; // // Predefined: bool IsCompleted { get; } // is_completed = MemberCache.FindMember(awaiter_type, MemberFilter.Property("IsCompleted", bc.Module.Compiler.BuiltinTypes.Bool), BindingRestriction.InstanceOnly) as PropertySpec; if (is_completed == null || !is_completed.HasGet) { Error_WrongAwaiterPattern(bc, awaiter_type); return(false); } // // Predefined: GetResult () // // The method return type is also result type of await expression // get_result = MemberCache.FindMember(awaiter_type, MemberFilter.Method("GetResult", 0, ParametersCompiled.EmptyReadOnlyParameters, null), BindingRestriction.InstanceOnly) as MethodSpec; if (get_result == null) { Error_WrongAwaiterPattern(bc, awaiter_type); return(false); } // // Predefined: INotifyCompletion.OnCompleted (System.Action) // var nc = bc.Module.PredefinedTypes.INotifyCompletion; if (nc.Define() && !awaiter_type.ImplementsInterface(nc.TypeSpec, false)) { bc.Report.Error(4027, loc, "The awaiter type `{0}' must implement interface `{1}'", awaiter_type.GetSignatureForError(), nc.GetSignatureForError()); return(false); } result_type = get_result.ReturnType; return(true); }