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));
}
