public RemoveParametersRefactoring(IDeclarationFinderProvider declarationFinderProvider, IRefactoringPresenterFactory factory, IRewritingManager rewritingManager, ISelectionService selectionService) { _declarationFinderProvider = declarationFinderProvider; _selectionService = selectionService; _rewritingManager = rewritingManager; _presenterFactory = (model => DisposalActionContainer.Create(factory.Create <IRemoveParametersPresenter, RemoveParametersModel>(model), factory.Release)); }
public void Refactor() { _model = InitializeModel(); if (_model == null) { return; } using (var container = DisposalActionContainer.Create(_factory.Create <IEncapsulateFieldPresenter, EncapsulateFieldModel>(_model), p => _factory.Release(p))) { var presenter = container.Value; if (presenter == null) { return; } _model = presenter.Show(); if (_model == null) { return; } var rewriteSession = _rewritingManager.CheckOutCodePaneSession(); AddProperty(rewriteSession); rewriteSession.TryRewrite(); } }
public void Refactor() { _model = InitializeModel(); if (_model == null) { return; } using (var container = DisposalActionContainer.Create(_factory.Create <IReorderParametersPresenter, ReorderParametersModel>(_model), p => _factory.Release(p))) { var presenter = container.Value; if (presenter == null) { return; } _model = presenter.Show(); if (_model == null || !_model.Parameters.Where((param, index) => param.Index != index).Any() || !IsValidParamOrder()) { return; } var rewriteSession = _rewritingManager.CheckOutCodePaneSession(); AdjustReferences(_model.TargetDeclaration.References, rewriteSession); AdjustSignatures(rewriteSession); rewriteSession.TryRewrite(); _model.State.OnParseRequested(this); } }
public void ValueReturnsValuePassedIn() { var testValue = 42; var dac = DisposalActionContainer.Create(testValue, () => { }); var returnedValue = dac.Value; Assert.AreEqual(testValue, returnedValue); }
public ExtractInterfaceRefactoring(IDeclarationFinderProvider declarationFinderProvider, IParseManager parseManager, IMessageBox messageBox, IRefactoringPresenterFactory factory, IRewritingManager rewritingManager, ISelectionService selectionService) { _declarationFinderProvider = declarationFinderProvider; _parseManager = parseManager; _rewritingManager = rewritingManager; _messageBox = messageBox; _selectionService = selectionService; _presenterFactory = ((model) => DisposalActionContainer.Create(factory.Create <IExtractInterfacePresenter, ExtractInterfaceModel>(model), factory.Release)); }
public void FirstDisposeTriggersActionPassedIn() { var useCount = 0; var dac = DisposalActionContainer.Create(42, () => useCount++); dac.Dispose(); var expectedUseCount = 1; Assert.AreEqual(expectedUseCount, useCount); }
public void ArgumentForActionPassedInIsTheValuePassedIn() { var actualArgumentValue = 0; var dac = DisposalActionContainer.Create(42, (a) => actualArgumentValue = a); dac.Dispose(); var expectedArgumentValue = 42; Assert.AreEqual(expectedArgumentValue, actualArgumentValue); }
protected InteractiveRefactoringBase( IRewritingManager rewritingManager, ISelectionProvider selectionProvider, IRefactoringPresenterFactory factory, IUiDispatcher uiDispatcher) : base(rewritingManager, selectionProvider) { Action <TPresenter> presenterDisposalAction = (TPresenter presenter) => uiDispatcher.Invoke(() => factory.Release(presenter)); _presenterFactory = ((model) => DisposalActionContainer.Create(factory.Create <TPresenter, TModel>(model), presenterDisposalAction)); }
private void GetEnumerationMembers(ITypeInfo info, TYPEATTR attrib) { var count = attrib.cVars; for (var index = 0; index < count; index++) { info.GetVarDesc(index, out IntPtr varPtr); using (DisposalActionContainer.Create(varPtr, info.ReleaseVarDesc)) { var desc = Marshal.PtrToStructure <VARDESC>(varPtr); Members.Add(new ComEnumerationMember(this, info, desc)); } } }
private void GetFieldType(TYPEDESC desc, ITypeInfo info) { var vt = (VarEnum)desc.vt; TYPEDESC tdesc; if (vt == VarEnum.VT_PTR) { tdesc = Marshal.PtrToStructure <TYPEDESC>(desc.lpValue); GetFieldType(tdesc, info); } else if (vt == VarEnum.VT_USERDEFINED) { int href; unchecked { //The href is a long, but the size of lpValue depends on the platform, so truncate it after the lword. href = (int)(desc.lpValue.ToInt64() & 0xFFFFFFFF); } try { info.GetRefTypeInfo(href, out ITypeInfo refTypeInfo); refTypeInfo.GetTypeAttr(out IntPtr attribPtr); using (DisposalActionContainer.Create(attribPtr, refTypeInfo.ReleaseTypeAttr)) { var attribs = Marshal.PtrToStructure <TYPEATTR>(attribPtr); if (attribs.typekind == TYPEKIND.TKIND_ENUM) { _enumGuid = attribs.guid; } IsReferenceType = ReferenceTypeKinds.Contains(attribs.typekind); _valueType = new ComDocumentation(refTypeInfo, ComDocumentation.LibraryIndex).Name; } } catch (COMException) { } } else if (vt == VarEnum.VT_SAFEARRAY || vt == VarEnum.VT_CARRAY || vt.HasFlag(VarEnum.VT_ARRAY)) { tdesc = Marshal.PtrToStructure <TYPEDESC>(desc.lpValue); GetFieldType(tdesc, info); IsArray = true; } else { if (ComVariant.TypeNames.TryGetValue(vt, out string result)) { _valueType = result; } } }
public void MultipleCallsOfDisposeTriggerTheActionPassedInOnce() { var useCount = 0; var dac = DisposalActionContainer.Create(42, () => useCount++); dac.Dispose(); dac.Dispose(); dac.Dispose(); dac.Dispose(); dac.Dispose(); dac.Dispose(); var expectedUseCount = 1; Assert.AreEqual(expectedUseCount, useCount); }
private void GetComMembers(ITypeInfo info, TYPEATTR attrib) { for (var index = 0; index < attrib.cFuncs; index++) { info.GetFuncDesc(index, out IntPtr memberPtr); using (DisposalActionContainer.Create(memberPtr, info.ReleaseFuncDesc)) { var member = Marshal.PtrToStructure <FUNCDESC>(memberPtr); if (member.callconv != CALLCONV.CC_STDCALL) { continue; } _members.Add(new ComMember(this, info, member)); } } }
private void GetComFields(ITypeInfo info, TYPEATTR attrib) { var names = new string[1]; for (var index = 0; index < attrib.cVars; index++) { info.GetVarDesc(index, out IntPtr varPtr); using (DisposalActionContainer.Create(varPtr, info.ReleaseVarDesc)) { var desc = Marshal.PtrToStructure <VARDESC>(varPtr); info.GetNames(desc.memid, names, names.Length, out int length); Debug.Assert(length == 1); _fields.Add(new ComField(this, info, names[0], desc, index, DeclarationType.Constant)); } } }
public ReferenceInfo GetReferenceInfo(ITypeLib typelib, string name, string path) { try { typelib.GetLibAttr(out var attributes); using (DisposalActionContainer.Create(attributes, typelib.ReleaseTLibAttr)) { var typeAttr = Marshal.PtrToStructure <System.Runtime.InteropServices.ComTypes.TYPELIBATTR>(attributes); return(new ReferenceInfo(typeAttr.guid, name, path, typeAttr.wMajorVerNum, typeAttr.wMinorVerNum)); } } catch { return(ReferenceInfo.Empty); } }
private void GetComFields(ITypeInfo info, TYPEATTR attrib) { var names = new string[1]; for (var index = 0; index < attrib.cVars; index++) { info.GetVarDesc(index, out IntPtr varPtr); using (DisposalActionContainer.Create(varPtr, info.ReleaseVarDesc)) { var desc = Marshal.PtrToStructure <VARDESC>(varPtr); info.GetNames(desc.memid, names, names.Length, out int length); Debug.Assert(length == 1); DeclarationType type; if (info is ITypeInfoWrapper wrapped && wrapped.HasVBEExtensions) { type = desc.IsValidVBAConstant() ? DeclarationType.Constant : DeclarationType.Variable; }
public ComProject(ITypeLib typeLibrary, string path) : base(null, typeLibrary, -1) { Path = path; try { typeLibrary.GetLibAttr(out IntPtr attribPtr); using (DisposalActionContainer.Create(attribPtr, typeLibrary.ReleaseTLibAttr)) { var typeAttr = Marshal.PtrToStructure <TYPELIBATTR>(attribPtr); MajorVersion = typeAttr.wMajorVerNum; MinorVersion = typeAttr.wMinorVerNum; _flags = (TypeLibTypeFlags)typeAttr.wLibFlags; Guid = typeAttr.guid; } } catch (COMException) { } LoadModules(typeLibrary); }
private void GetImplementedInterfaces(ITypeInfo info, TYPEATTR typeAttr) { IsExtensible = !typeAttr.wTypeFlags.HasFlag(TYPEFLAGS.TYPEFLAG_FNONEXTENSIBLE); for (var implIndex = 0; implIndex < typeAttr.cImplTypes; implIndex++) { info.GetRefTypeOfImplType(implIndex, out int href); info.GetRefTypeInfo(href, out ITypeInfo implemented); implemented.GetTypeAttr(out IntPtr attribPtr); using (DisposalActionContainer.Create(attribPtr, implemented.ReleaseTypeAttr)) { var attribs = Marshal.PtrToStructure <TYPEATTR>(attribPtr); ComProject.KnownTypes.TryGetValue(attribs.guid, out ComType inherited); var intface = inherited as ComInterface ?? new ComInterface(Project, implemented, attribs); _inherited.Add(intface); ComProject.KnownTypes.TryAdd(attribs.guid, intface); } } }
private void GetImplementedInterfaces(ITypeInfo info, TYPEATTR typeAttr) { for (var implIndex = 0; implIndex < typeAttr.cImplTypes; implIndex++) { info.GetRefTypeOfImplType(implIndex, out int href); info.GetRefTypeInfo(href, out ITypeInfo implemented); implemented.GetTypeAttr(out IntPtr attribPtr); using (DisposalActionContainer.Create(attribPtr, info.ReleaseTypeAttr)) { var attribs = Marshal.PtrToStructure <TYPEATTR>(attribPtr); ComProject.KnownTypes.TryGetValue(attribs.guid, out ComType inherited); var intface = inherited as ComInterface ?? new ComInterface(Project, implemented, attribs); ComProject.KnownTypes.TryAdd(attribs.guid, intface); IMPLTYPEFLAGS flags = 0; try { info.GetImplTypeFlags(implIndex, out flags); } catch (COMException) { } if (flags.HasFlag(IMPLTYPEFLAGS.IMPLTYPEFLAG_FSOURCE)) { _events.Add(intface); } else { DefaultInterface = flags.HasFlag(IMPLTYPEFLAGS.IMPLTYPEFLAG_FDEFAULT) ? intface : DefaultInterface; } _interfaces.Add(intface, flags.HasFlag(IMPLTYPEFLAGS.IMPLTYPEFLAG_FRESTRICTED)); } } if (DefaultInterface == null) { DefaultInterface = VisibleInterfaces.FirstOrDefault(); } }
public RenameRefactoring(IRefactoringPresenterFactory factory, IMessageBox messageBox, IDeclarationFinderProvider declarationFinderProvider, IProjectsProvider projectsProvider, IRewritingManager rewritingManager, ISelectionService selectionService) { _messageBox = messageBox; _declarationFinderProvider = declarationFinderProvider; _projectsProvider = projectsProvider; _rewritingManager = rewritingManager; _selectionService = selectionService; _model = null; _presenterFactory = ((model) => DisposalActionContainer.Create(factory.Create <IRenamePresenter, RenameModel>(model), factory.Release)); _renameActions = new Dictionary <DeclarationType, Action <IRewriteSession> > { { DeclarationType.Member, RenameMember }, { DeclarationType.Parameter, RenameParameter }, { DeclarationType.Event, RenameEvent }, { DeclarationType.Variable, RenameVariable }, { DeclarationType.Module, RenameModule }, { DeclarationType.Project, RenameProject } }; IsInterfaceMemberRename = false; _neverRenameIdentifiers = NeverRenameList(); }
public ComInterface(IComBase parent, ITypeInfo info, TYPEATTR attrib) : base(parent, info, attrib) { // Since the reference declaration gathering is threaded, this can't be truly recursive, so implemented interfaces may have // null parents (for example, if the library references a type library that isn't referenced by the VBA project or if that project // hasn't had the implemented interface processed yet). try { info.GetContainingTypeLib(out var typeLib, out _); typeLib.GetLibAttr(out IntPtr attribPtr); using (DisposalActionContainer.Create(attribPtr, typeLib.ReleaseTLibAttr)) { var typeAttr = Marshal.PtrToStructure <TYPELIBATTR>(attribPtr); Parent = typeAttr.guid.Equals(parent?.Project.Guid) ? parent?.Project : null; } } catch { Parent = null; } GetImplementedInterfaces(info, attrib); GetComProperties(info, attrib); GetComMembers(info, attrib); }
private void LoadModules(ITypeLib typeLibrary) { var typeCount = typeLibrary.GetTypeInfoCount(); for (var index = 0; index < typeCount; index++) { try { typeLibrary.GetTypeInfo(index, out ITypeInfo info); info.GetTypeAttr(out var typeAttributesPointer); using (DisposalActionContainer.Create(typeAttributesPointer, info.ReleaseTypeAttr)) { var typeAttributes = Marshal.PtrToStructure <TYPEATTR>(typeAttributesPointer); KnownTypes.TryGetValue(typeAttributes.guid, out var type); switch (typeAttributes.typekind) { case TYPEKIND.TKIND_ENUM: var enumeration = type ?? new ComEnumeration(this, typeLibrary, info, typeAttributes, index); Debug.Assert(enumeration is ComEnumeration); _enumerations.Add(enumeration as ComEnumeration); if (type == null && !enumeration.Guid.Equals(Guid.Empty)) { KnownTypes.TryAdd(typeAttributes.guid, enumeration); } break; case TYPEKIND.TKIND_COCLASS: var coclass = type ?? new ComCoClass(this, typeLibrary, info, typeAttributes, index); Debug.Assert(coclass is ComCoClass && !coclass.Guid.Equals(Guid.Empty)); _classes.Add(coclass as ComCoClass); if (type == null) { KnownTypes.TryAdd(typeAttributes.guid, coclass); } break; case TYPEKIND.TKIND_DISPATCH: case TYPEKIND.TKIND_INTERFACE: var intface = type ?? new ComInterface(this, typeLibrary, info, typeAttributes, index); Debug.Assert(intface is ComInterface && !intface.Guid.Equals(Guid.Empty)); _interfaces.Add(intface as ComInterface); if (type == null) { KnownTypes.TryAdd(typeAttributes.guid, intface); } break; case TYPEKIND.TKIND_RECORD: var structure = new ComStruct(this, typeLibrary, info, typeAttributes, index); _structs.Add(structure); break; case TYPEKIND.TKIND_MODULE: var module = type ?? new ComModule(this, typeLibrary, info, typeAttributes, index); Debug.Assert(module is ComModule); _modules.Add(module as ComModule); if (type == null && !module.Guid.Equals(Guid.Empty)) { KnownTypes.TryAdd(typeAttributes.guid, module); } break; case TYPEKIND.TKIND_ALIAS: var alias = new ComAlias(this, typeLibrary, info, index, typeAttributes); _aliases.Add(alias); if (alias.Guid != Guid.Empty) { KnownAliases.TryAdd(alias.Guid, alias); } break; case TYPEKIND.TKIND_UNION: //TKIND_UNION is not a supported member type in VBA. break; default: throw new NotImplementedException($"Didn't expect a TYPEATTR with multiple typekind flags set in {Path}."); } } } catch (COMException) { } } ApplySpecificLibraryTweaks(); }
public RefactoringUserInteraction(IRefactoringPresenterFactory factory, IUiDispatcher uiDispatcher) { Action <TPresenter> presenterDisposalAction = (TPresenter presenter) => uiDispatcher.Invoke(() => factory.Release(presenter)); _presenterFactory = ((model) => DisposalActionContainer.Create(factory.Create <TPresenter, TModel>(model), presenterDisposalAction)); }
private void GetParameterType(TYPEDESC desc, ITypeInfo info) { var vt = (VarEnum)desc.vt; TYPEDESC tdesc; if (vt == VarEnum.VT_PTR) { tdesc = Marshal.PtrToStructure <TYPEDESC>(desc.lpValue); GetParameterType(tdesc, info); IsByRef = true; } else if (vt == VarEnum.VT_USERDEFINED) { int href; unchecked { href = (int)(desc.lpValue.ToInt64() & 0xFFFFFFFF); } try { info.GetRefTypeInfo(href, out ITypeInfo refTypeInfo); refTypeInfo.GetTypeAttr(out IntPtr attribPtr); using (DisposalActionContainer.Create(attribPtr, refTypeInfo.ReleaseTypeAttr)) { var attribs = Marshal.PtrToStructure <TYPEATTR>(attribPtr); var type = new ComDocumentation(refTypeInfo, ComDocumentation.LibraryIndex).Name; if (attribs.typekind == TYPEKIND.TKIND_ENUM) { _typeName = new ComTypeName(Project, type, attribs.guid, Guid.Empty); } else if (attribs.typekind == TYPEKIND.TKIND_ALIAS) { _typeName = new ComTypeName(Project, type, Guid.Empty, attribs.guid); } else { _typeName = new ComTypeName(Project, type); } } } catch (COMException) { _typeName = new ComTypeName(Project, Tokens.Object); } } else if (vt == VarEnum.VT_SAFEARRAY || vt == VarEnum.VT_CARRAY || vt.HasFlag(VarEnum.VT_ARRAY)) { tdesc = Marshal.PtrToStructure <TYPEDESC>(desc.lpValue); GetParameterType(tdesc, info); IsArray = true; } else if (vt == VarEnum.VT_HRESULT) { _typeName = new ComTypeName(Project, Tokens.Long); } else { _typeName = new ComTypeName(Project, (ComVariant.TypeNames.TryGetValue(vt, out string result)) ? result : Tokens.Object); } }