public static CodeModuleSelection FindInstruction(this VBE vbe, QualifiedModuleName qualifiedModuleName, Selection selection) { var module = qualifiedModuleName.Component.CodeModule; if (module == null) { return null; } return new CodeModuleSelection(module, selection); }
private ParameterDeclaration CreateParameterDeclaration(IReadOnlyList <string> memberNames, int paramIndex, FUNCDESC memberDescriptor, QualifiedModuleName typeQualifiedModuleName, Declaration memberDeclaration, ITypeInfo info) { var paramName = memberNames[paramIndex + 1]; var paramPointer = new IntPtr(memberDescriptor.lprgelemdescParam.ToInt64() + Marshal.SizeOf(typeof(ELEMDESC)) * paramIndex); var elementDesc = (ELEMDESC)Marshal.PtrToStructure(paramPointer, typeof(ELEMDESC)); var isOptional = elementDesc.desc.paramdesc.wParamFlags.HasFlag(PARAMFLAG.PARAMFLAG_FOPT); var paramDesc = elementDesc.tdesc; var paramInfo = GetParameterInfo(paramDesc, info); return(new ParameterDeclaration(new QualifiedMemberName(typeQualifiedModuleName, paramName), memberDeclaration, paramInfo.Name, null, null, isOptional, paramInfo.IsByRef, paramInfo.IsArray)); }
public List <Declaration> GetDeclarationsForReference(Reference reference) { var output = new List <Declaration>(); var projectName = reference.Name; var path = reference.FullPath; ITypeLib typeLibrary; // Failure to load might mean that it's a "normal" VBProject that will get parsed by us anyway. LoadTypeLibEx(path, REGKIND.REGKIND_NONE, out typeLibrary); if (typeLibrary == null) { return(output); } var projectQualifiedModuleName = new QualifiedModuleName(projectName, path, projectName); var projectQualifiedMemberName = new QualifiedMemberName(projectQualifiedModuleName, projectName); var projectDeclaration = new ProjectDeclaration(projectQualifiedMemberName, projectName, isBuiltIn: true); output.Add(projectDeclaration); var typeCount = typeLibrary.GetTypeInfoCount(); for (var i = 0; i < typeCount; i++) { ITypeInfo info; try { typeLibrary.GetTypeInfo(i, out info); } catch (NullReferenceException) { return(output); } if (info == null) { continue; } var typeName = GetTypeName(info); var typeDeclarationType = GetDeclarationType(typeLibrary, i); QualifiedModuleName typeQualifiedModuleName; QualifiedMemberName typeQualifiedMemberName; if (typeDeclarationType == DeclarationType.Enumeration || typeDeclarationType == DeclarationType.UserDefinedType) { typeQualifiedModuleName = projectQualifiedModuleName; typeQualifiedMemberName = new QualifiedMemberName(projectQualifiedModuleName, typeName); } else { typeQualifiedModuleName = new QualifiedModuleName(projectName, path, typeName); typeQualifiedMemberName = new QualifiedMemberName(typeQualifiedModuleName, typeName); } IntPtr typeAttributesPointer; info.GetTypeAttr(out typeAttributesPointer); var typeAttributes = (TYPEATTR)Marshal.PtrToStructure(typeAttributesPointer, typeof(TYPEATTR)); var attributes = new Attributes(); if (typeAttributes.wTypeFlags.HasFlag(TYPEFLAGS.TYPEFLAG_FPREDECLID)) { attributes.AddPredeclaredIdTypeAttribute(); } if (typeAttributes.wTypeFlags.HasFlag(TYPEFLAGS.TYPEFLAG_FAPPOBJECT)) { attributes.AddGlobalClassAttribute(); } Declaration moduleDeclaration; switch (typeDeclarationType) { case DeclarationType.ProceduralModule: moduleDeclaration = new ProceduralModuleDeclaration(typeQualifiedMemberName, projectDeclaration, typeName, true, new List <IAnnotation>(), attributes); break; case DeclarationType.ClassModule: var module = new ClassModuleDeclaration(typeQualifiedMemberName, projectDeclaration, typeName, true, new List <IAnnotation>(), attributes); var implements = GetImplementedInterfaceNames(typeAttributes, info, module); foreach (var supertypeName in implements) { module.AddSupertype(supertypeName); } moduleDeclaration = module; break; default: string pseudoModuleName = string.Format("_{0}", typeName); var pseudoParentModule = new ProceduralModuleDeclaration( new QualifiedMemberName(projectQualifiedModuleName, pseudoModuleName), projectDeclaration, pseudoModuleName, true, new List <IAnnotation>(), new Attributes()); // Enums don't define their own type but have a declared type of "Long". if (typeDeclarationType == DeclarationType.Enumeration) { typeName = Tokens.Long; } // UDTs and ENUMs don't seem to have a module parent that's why we add a "fake" module // so that the rest of the application can treat it normally. moduleDeclaration = new Declaration( typeQualifiedMemberName, pseudoParentModule, pseudoParentModule, typeName, null, false, false, Accessibility.Global, typeDeclarationType, null, Selection.Home, false, null, true, null, attributes); break; } if (typeAttributes.guid == Guid.Empty) { LoadDeclarationsInModule(output, new ComInformation(typeAttributes, 0, info, typeName, typeQualifiedModuleName, moduleDeclaration, typeDeclarationType)); } else { ComInformation comInfo; if (_comInformation.TryGetValue(typeAttributes.guid, out comInfo)) { comInfo.TypeQualifiedModuleName = typeQualifiedModuleName; comInfo.ModuleDeclaration = moduleDeclaration; comInfo.TypeDeclarationType = typeDeclarationType; } else { _comInformation.Add(typeAttributes.guid, new ComInformation(typeAttributes, 0, info, typeName, typeQualifiedModuleName, moduleDeclaration, typeDeclarationType)); } } info.ReleaseTypeAttr(typeAttributesPointer); output.Add(moduleDeclaration); } foreach (var member in _comInformation.Values) { LoadDeclarationsInModule(output, member); } return(output); }
public void ClearSupertypes(QualifiedModuleName module) { _supertypeClearer.ClearSupertypes(module); }
public void AddModuleToModuleReference(QualifiedModuleName referencingModule, QualifiedModuleName referencedModule) { _moduleToModuleReferenceManager.AddModuleToModuleReference(referencingModule, referencedModule); }
/// <summary> /// Exports the specified component to a temporary file, loads, and then parses the exported file. /// </summary> /// <param name="module"></param> /// <param name="cancellationToken"></param> public (IParseTree tree, ITokenStream tokenStream, IDictionary <Tuple <string, DeclarationType>, Attributes> attributes) Parse(QualifiedModuleName module, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); var path = _exporter.Export(_projectsProvider.Component(module)); if (!File.Exists(path)) { // a document component without any code wouldn't be exported (file would be empty anyway). return(null, null, new Dictionary <Tuple <string, DeclarationType>, Attributes>()); } string code; if (module.ComponentType == ComponentType.Document) { code = File.ReadAllText(path, Encoding.UTF8); //We export the code from Documents as UTF8. } else { code = File.ReadAllText(path, Encoding.Default); //The VBE exports encoded in the current ANSI codepage from the windows settings. } try { File.Delete(path); } catch { // Meh. } cancellationToken.ThrowIfCancellationRequested(); var type = module.ComponentType == ComponentType.StandardModule ? DeclarationType.ProceduralModule : DeclarationType.ClassModule; var tokenStreamProvider = new SimpleVBAModuleTokenStreamProvider(); var tokens = tokenStreamProvider.Tokens(code); var preprocessor = _preprocessorFactory(); var preprocessorErrorListener = new PreprocessorExceptionErrorListener(module.ComponentName, ParsePass.AttributesPass); preprocessor.PreprocessTokenStream(module.ComponentName, tokens, preprocessorErrorListener, cancellationToken); var listener = new AttributeListener(Tuple.Create(module.ComponentName, type)); // parse tree isn't usable for declarations because // line numbers are offset due to module header and attributes // (these don't show up in the VBE, that's why we're parsing an exported file) var mainParseErrorListener = new MainParseExceptionErrorListener(module.ComponentName, ParsePass.AttributesPass); var parseResults = new VBAModuleParser().Parse(module.ComponentName, tokens, new IParseTreeListener[] { listener }, mainParseErrorListener); cancellationToken.ThrowIfCancellationRequested(); return(parseResults.tree, parseResults.tokenStream, listener.Attributes); }
private static string FormattedDeclaration( Declaration declaration, string typeName, QualifiedModuleName moduleName, string declarationType) { if (declaration.ParentDeclaration != null) { if (declaration.ParentDeclaration.DeclarationType.HasFlag(DeclarationType.Member)) { // locals, parameters return($"{declaration.ParentDeclaration.QualifiedName}:{declaration.IdentifierName} {typeName}"); } if (declaration.ParentDeclaration.DeclarationType.HasFlag(DeclarationType.Module)) { // fields var withEvents = declaration.IsWithEvents ? "(WithEvents) " : string.Empty; return($"{withEvents}{moduleName}.{declaration.IdentifierName} {typeName}"); } } if (declaration.DeclarationType.HasFlag(DeclarationType.Member)) { var formattedDeclaration = declaration.QualifiedName.ToString(); if (declaration.DeclarationType == DeclarationType.Function || declaration.DeclarationType == DeclarationType.PropertyGet) { formattedDeclaration += typeName; } return(formattedDeclaration); } if (declaration.DeclarationType.HasFlag(DeclarationType.Module)) { return($"{moduleName} ({declarationType})"); } switch (declaration.DeclarationType) { case DeclarationType.Project: case DeclarationType.BracketedExpression: var filename = System.IO.Path.GetFileName(declaration.QualifiedName.QualifiedModuleName.ProjectPath); return($"{filename}{(string.IsNullOrEmpty(filename) ? string.Empty : ";")}{declaration.IdentifierName} ({declarationType})"); case DeclarationType.Enumeration: case DeclarationType.UserDefinedType: return(!declaration.IsUserDefined // built-in enums & UDT's don't have a module ? $"{System.IO.Path.GetFileName(moduleName.ProjectPath)};{moduleName.ProjectName}.{declaration.IdentifierName}" : moduleName.ToString()); case DeclarationType.EnumerationMember: case DeclarationType.UserDefinedTypeMember: return(declaration.IsUserDefined ? $"{moduleName}.{declaration.ParentDeclaration.IdentifierName}.{declaration.IdentifierName} {typeName}" : $"{System.IO.Path.GetFileName(moduleName.ProjectPath)};{moduleName.ProjectName}.{declaration.ParentDeclaration.IdentifierName}.{declaration.IdentifierName} {typeName}"); case DeclarationType.ComAlias: return($"{System.IO.Path.GetFileName(moduleName.ProjectPath)};{moduleName.ProjectName}.{declaration.IdentifierName} (alias:{declaration.AsTypeName})"); } return(string.Empty); }
private void Fix(QualifiedModuleName moduleName, VBAParser.AnnotationContext context) { AttributeFixActions[context.AnnotationType].Invoke(_state, moduleName); }
public override IReadOnlyCollection <QualifiedModuleName> ModulesReferencedBy(QualifiedModuleName referencingModule) { ConcurrentDictionary <QualifiedModuleName, byte> referencedModules; return(_referencesFrom.TryGetValue(referencingModule, out referencedModules) ? referencedModules.Keys.ToHashSet().AsReadOnly() : new HashSet <QualifiedModuleName>().AsReadOnly()); }
public override void RemoveModuleToModuleReference(QualifiedModuleName referencedModule, QualifiedModuleName referencingModule) { byte dummyOutValue; ConcurrentDictionary <QualifiedModuleName, byte> referencedModules; if (_referencesFrom.TryGetValue(referencingModule, out referencedModules)) { referencedModules.TryRemove(referencedModule, out dummyOutValue); } ConcurrentDictionary <QualifiedModuleName, byte> referencingModules; if (_referencesTo.TryGetValue(referencedModule, out referencingModules)) { referencingModules.TryRemove(referencingModule, out dummyOutValue); } }
public override void AddModuleToModuleReference(QualifiedModuleName referencingModule, QualifiedModuleName referencedModule) { ConcurrentDictionary <QualifiedModuleName, byte> referencedModules; ConcurrentDictionary <QualifiedModuleName, byte> referencingModules; while (!_referencesFrom.TryGetValue(referencingModule, out referencedModules) || !_referencesTo.TryGetValue(referencedModule, out referencingModules)) { _referencesFrom.AddOrUpdate(referencingModule, new ConcurrentDictionary <QualifiedModuleName, byte>(), (key, value) => value); _referencesTo.AddOrUpdate(referencedModule, new ConcurrentDictionary <QualifiedModuleName, byte>(), (key, value) => value); } referencedModules.AddOrUpdate(referencedModule, 0, (key, value) => value); referencingModules.AddOrUpdate(referencingModule, 0, (key, value) => value); }
private Declaration SupertypeForDocument(QualifiedModuleName module, RubberduckParserState state) { if (module.ComponentType != ComponentType.Document) { return(null); } var component = _state.ProjectsProvider.Component(module); if (component == null || component.IsWrappingNullReference) { return(null); } Declaration superType = null; // TODO: Replace with TypeLibAPI call, require a solution regarding thread synchronization or caching /* * using (var properties = component.Properties) * { * int documentPropertyCount = 0; * try * { * if (properties == null || properties.IsWrappingNullReference) * { * return null; * } * documentPropertyCount = properties.Count; * } * catch(COMException) * { * return null; * } * * foreach (var coclass in state.CoClasses) * { * try * { * if (coclass.Key.Count != documentPropertyCount) * { * continue; * } * * var allNamesMatch = true; * for (var i = 0; i < coclass.Key.Count; i++) * { * using (var property = properties[i+1]) * { * if (coclass.Key[i] != property?.Name) * { * allNamesMatch = false; * break; * } * } * } * * if (allNamesMatch) * { * superType = coclass.Value; * break; * } * } * catch (COMException) * { * } * } * } */ return(superType); }
public ProjectDeclaration(ComProject project, QualifiedModuleName module) : this(module.QualifyMemberName(project.Name), project.Name, false, null) { MajorVersion = project.MajorVersion; MinorVersion = project.MinorVersion; }
public ParseErrorEventArgs(SyntaxErrorException exception, QualifiedModuleName moduleName) { Exception = exception; _moduleName = moduleName; }
public IExecutableModuleRewriter CodePaneRewriter(QualifiedModuleName module, ITokenStream tokenStream) { return(new ModuleRewriter(module, tokenStream, _codePaneSourceCodeHandlerr)); }
public int GetHashCode(QualifiedModuleName obj) { return(GetHashCode(obj.Name)); }
public IExecutableModuleRewriter AttributesRewriter(QualifiedModuleName module, ITokenStream tokenStream) { return(new ModuleRewriter(module, tokenStream, _attributesSourceCodeHandler)); }
public IVBComponent Component(QualifiedModuleName qualifiedModuleName) { return(EvaluateWithinReadLock(() => _components.TryGetValue(qualifiedModuleName, out var component) ? component : null)); }
public IParseTree GetParseTree(string moduleName) { QualifiedModuleName qualifiedModuleName = ProjectManager.AllModules().FirstOrDefault(x => x.ComponentName == moduleName); return(qualifiedModuleName != default(QualifiedModuleName) ? ParserState.GetParseTree(qualifiedModuleName) : null); }
public OptionBaseInspectionResult(string inspection, CodeInspectionSeverity type, QualifiedModuleName qualifiedName) : base(inspection, type, new CommentNode("", new QualifiedSelection(qualifiedName, Selection.Home))) { }
private static (ICollection <Declaration> memberDeclarations, Declaration defaultMemberDeclaration) GetDeclarationsForMembers(IEnumerable <ComMember> members, QualifiedModuleName moduleName, Declaration moduleDeclaration, ComMember defaultMember, bool eventHandlers = false) { var memberDeclarations = new List <Declaration>(); Declaration defaultMemberDeclaration = null; foreach (var item in members.Where(m => !m.IsRestricted && !IgnoredInterfaceMembers.Contains(m.Name))) { var(memberDeclaration, parameterDeclarations) = GetDeclarationsForMember(moduleName, moduleDeclaration, eventHandlers, item); memberDeclarations.Add(memberDeclaration); memberDeclarations.AddRange(parameterDeclarations); if (moduleDeclaration is ClassModuleDeclaration && item == defaultMember) { defaultMemberDeclaration = memberDeclaration; } } return(memberDeclarations, defaultMemberDeclaration); }
public void RemoveReferencesTo(QualifiedModuleName module, CancellationToken token) { _referenceRemover.RemoveReferencesTo(module, token); }
private static (Declaration memberDeclaration, List <Declaration> parameterDeclarations) GetDeclarationsForMember(QualifiedModuleName moduleName, Declaration parentDeclaration, bool eventHandlers, ComMember item) { var memberDeclaration = CreateMemberDeclaration(item, moduleName, parentDeclaration, eventHandlers); var parameterDeclarations = new List <Declaration>(); if (memberDeclaration is IParameterizedDeclaration hasParams) { parameterDeclarations.AddRange(hasParams.Parameters); } return(memberDeclaration, parameterDeclarations); }
public void ClearModuleToModuleReferencesToModule(QualifiedModuleName referencedModule) { _moduleToModuleReferenceManager.ClearModuleToModuleReferencesToModule(referencedModule); }
private static (Declaration getter, Declaration writer) GetDeclarationsForProperty(QualifiedModuleName moduleName, Declaration moduleDeclaration, ComField item, Attributes attributes) { var getter = new PropertyGetDeclaration(item, moduleDeclaration, moduleName, attributes); if (item.Flags.HasFlag(VARFLAGS.VARFLAG_FREADONLY)) { return(getter, null); } if (item.IsReferenceType) { var setter = new PropertySetDeclaration(item, moduleDeclaration, moduleName, attributes); return(getter, setter); } var letter = new PropertyLetDeclaration(item, moduleDeclaration, moduleName, attributes); return(getter, letter); }
public IReadOnlyCollection <QualifiedModuleName> ModulesReferencing(QualifiedModuleName referencedModule) { return(_moduleToModuleReferenceManager.ModulesReferencing(referencedModule)); }
private static ICollection <Declaration> GetDeclarationsForModule(IComType module, QualifiedModuleName moduleName, ProjectDeclaration project) { var declarations = new List <Declaration>(); var attributes = GetModuleAttributes(module); var moduleDeclaration = CreateModuleDeclaration(module, moduleName, project, attributes); declarations.Add(moduleDeclaration); switch (module) { case IComTypeWithMembers membered: var(memberDeclarations, defaultMember) = GetDeclarationsForProperties(membered.Properties, moduleName, moduleDeclaration); declarations.AddRange(memberDeclarations); AssignDefaultMember(moduleDeclaration, defaultMember); (memberDeclarations, defaultMember) = GetDeclarationsForMembers(membered.Members, moduleName, moduleDeclaration, membered.DefaultMember); declarations.AddRange(memberDeclarations); AssignDefaultMember(moduleDeclaration, defaultMember); if (membered is ComCoClass coClass) { (memberDeclarations, defaultMember) = GetDeclarationsForMembers(coClass.SourceMembers, moduleName, moduleDeclaration, coClass.DefaultMember, true); declarations.AddRange(memberDeclarations); AssignDefaultMember(moduleDeclaration, defaultMember); } break; case ComEnumeration enumeration: { var enumDeclaration = new Declaration(enumeration, moduleDeclaration, moduleName); declarations.Add(enumDeclaration); var members = enumeration.Members .Select(enumMember => new ValuedDeclaration(enumMember, enumDeclaration, moduleName)) .ToList(); declarations.AddRange(members); break; } case ComStruct structure: { var typeDeclaration = new Declaration(structure, moduleDeclaration, moduleName); declarations.Add(typeDeclaration); var members = structure.Fields .Select(f => new Declaration(f, typeDeclaration, moduleName)) .ToList(); declarations.AddRange(members); break; } } if (module is IComTypeWithFields fields && fields.Fields.Any()) { var projectName = project.QualifiedModuleName; var fieldDeclarations = new List <Declaration>(); foreach (var field in fields.Fields) { fieldDeclarations.Add(field.Type == DeclarationType.Constant ? new ValuedDeclaration(field, moduleDeclaration, projectName) : new Declaration(field, moduleDeclaration, projectName)); } declarations.AddRange(fieldDeclarations); } return(declarations); }
private Declaration CreateMemberDeclaration(FUNCDESC memberDescriptor, TYPEKIND typeKind, ITypeInfo info, IMPLTYPEFLAGS parentImplFlags, QualifiedModuleName typeQualifiedModuleName, Declaration moduleDeclaration, out string[] memberNames) { if (memberDescriptor.callconv != CALLCONV.CC_STDCALL) { memberNames = new string[] { }; return(null); } memberNames = new string[255]; int namesArrayLength; info.GetNames(memberDescriptor.memid, memberNames, 255, out namesArrayLength); var memberName = memberNames[0]; var funcValueType = (VarEnum)memberDescriptor.elemdescFunc.tdesc.vt; var memberDeclarationType = GetDeclarationType(memberName, memberDescriptor, funcValueType, typeKind, parentImplFlags); if (((FUNCFLAGS)memberDescriptor.wFuncFlags).HasFlag(FUNCFLAGS.FUNCFLAG_FRESTRICTED) && IgnoredInterfaceMembers.Contains(memberName)) // Ignore IDispatch and IUnknown members - quick-and-dirty for beta { return(null); } var asTypeName = new ComParameter(string.Empty, false); if (memberDeclarationType != DeclarationType.Procedure) { asTypeName = GetParameterInfo(memberDescriptor.elemdescFunc.tdesc, info); } var attributes = new Attributes(); if (memberName == "_NewEnum" && ((FUNCFLAGS)memberDescriptor.wFuncFlags).HasFlag(FUNCFLAGS.FUNCFLAG_FNONBROWSABLE)) { attributes.AddEnumeratorMemberAttribute(memberName); } else if (memberDescriptor.memid == 0) { attributes.AddDefaultMemberAttribute(memberName); } else if (((FUNCFLAGS)memberDescriptor.wFuncFlags).HasFlag(FUNCFLAGS.FUNCFLAG_FHIDDEN)) { attributes.AddHiddenMemberAttribute(memberName); } switch (memberDeclarationType) { case DeclarationType.Procedure: return(new SubroutineDeclaration( new QualifiedMemberName(typeQualifiedModuleName, memberName), moduleDeclaration, moduleDeclaration, asTypeName.Name, Accessibility.Global, null, Selection.Home, true, null, attributes)); case DeclarationType.Function: return(new FunctionDeclaration( new QualifiedMemberName(typeQualifiedModuleName, memberName), moduleDeclaration, moduleDeclaration, asTypeName.Name, null, null, Accessibility.Global, null, Selection.Home, asTypeName.IsArray, true, null, attributes)); case DeclarationType.PropertyGet: return(new PropertyGetDeclaration( new QualifiedMemberName(typeQualifiedModuleName, memberName), moduleDeclaration, moduleDeclaration, asTypeName.Name, null, null, Accessibility.Global, null, Selection.Home, asTypeName.IsArray, true, null, attributes)); case DeclarationType.PropertySet: return(new PropertySetDeclaration( new QualifiedMemberName(typeQualifiedModuleName, memberName), moduleDeclaration, moduleDeclaration, asTypeName.Name, Accessibility.Global, null, Selection.Home, true, null, attributes)); case DeclarationType.PropertyLet: return(new PropertyLetDeclaration( new QualifiedMemberName(typeQualifiedModuleName, memberName), moduleDeclaration, moduleDeclaration, asTypeName.Name, Accessibility.Global, null, Selection.Home, true, null, attributes)); default: return(new Declaration( new QualifiedMemberName(typeQualifiedModuleName, memberName), moduleDeclaration, moduleDeclaration, asTypeName.Name, null, false, false, Accessibility.Global, memberDeclarationType, null, Selection.Home, false, null, true, null, attributes)); } }
public abstract IReadOnlyCollection <QualifiedModuleName> ModulesReferencedBy(QualifiedModuleName referencingModule);
public static QualifiedSelection GetSelection(this CodePane pane) { int startLine; int endLine; int startColumn; int endColumn; if (pane == null) { return new QualifiedSelection(); } pane.GetSelection(out startLine, out startColumn, out endLine, out endColumn); if (endLine > startLine && endColumn == 1) { endLine--; endColumn = pane.CodeModule.get_Lines(endLine, 1).Length; } var selection = new Selection(startLine, startColumn, endLine, endColumn); var moduleName = new QualifiedModuleName(pane.CodeModule.Parent); return new QualifiedSelection(moduleName, selection); }
public abstract void RemoveModuleToModuleReference(QualifiedModuleName referencedModule, QualifiedModuleName referencingModule);
public QualifiedSelection(QualifiedModuleName qualifiedName, Selection selection) { _qualifiedName = qualifiedName; _selection = selection; }
public bool Equals(QualifiedModuleName x, QualifiedModuleName y) { return(Equals(x.Name, y.Name)); }