public ResolveExpr(ITargetDatabase db, CsGlobalNamespace globals, ResolveName nameResolver) { m_globals = globals; m_nameResolver = nameResolver; m_typeResolver = new ResolveType(db); m_memberResolver = new ResolveMembers(db); }
public Context(Script script, CsGlobalNamespace globals, string text, int selStart, int selLen) { Contract.Requires(script != null, "script is null"); Contract.Requires(globals != null, "globals is null"); Contract.Requires(text != null, "text is null"); Contract.Requires(selStart >= 0, "selStart is negative"); Contract.Requires(selLen >= 0, "selLen is negative"); Script = script; Text = text; Globals = globals; SelStart = selStart; SelLen = selLen; }
public Parse(int edit, string key, int index, int length, CsGlobalNamespace globals, Token[] comments, Token[] tokens) { Contract.Requires(!string.IsNullOrEmpty(key), "key is null or empty"); Contract.Requires(index >= 0, "index is negative"); Contract.Requires(length >= 0, "length is negative"); Contract.Requires(comments != null, "comments is null"); Contract.Requires(tokens != null, "tokens is null"); Contract.Requires(globals != null || length >= 0, "null globals but error length is not set"); Key = key; Edit = edit; ErrorIndex = index; ErrorLength = length; Globals = globals; Comments = comments; Tokens = tokens; }
public ResolveName(CsMember context, ITargetDatabase database, ICsLocalsParser locals, string text, int offset, CsGlobalNamespace globals) { Profile.Start("ResolveName::ctor"); m_database = database; m_typeResolver = new ResolveType(database); m_globals = globals; m_offset = offset; m_context = context; Profile.Start("DoFindMember"); m_member = DoFindMember(m_globals); Profile.Stop("DoFindMember"); Profile.Start("DoGetVariables"); m_variables = DoGetVariables(text, locals); Profile.Stop("DoGetVariables"); Profile.Stop("ResolveName::ctor"); }
// Usually this will return zero or one name, but it can return more (eg for explicit interface // implementations). public Item[] Find(CsMember context, ResolvedTarget target, CsGlobalNamespace globals, string name, int arity) { Profile.Start("ResolveMembers::Find"); var items = new List<Item>(); var types = new List<CsType>(); var baseNames = new List<string>(); var interfaceNames = new List<string>(); string[] allNames = DoGetBases(globals, target.TypeName, types, baseNames, interfaceNames); bool includeProtected = context != null && allNames.Contains(context.DeclaringType.FullName); foreach (CsType type in types) { var candidates = new List<Item>(); bool includePrivate = context != null && type.FullName == context.DeclaringType.FullName; DoGetParsedMembers(type, target.IsInstance, target.IsStatic, candidates, includePrivate, includeProtected); items = (from m in candidates where DoMatch(m, name, arity) select m).ToList(); } // Note that we need to make two GetMembers queries to ensure that interface // methods are not used in place of base methods (this gives us better results // when the context menu is used to filter out methods associated with types). DoAddIfMissingRange("Fields:", items, m_database.GetFields(baseNames.ToArray(), target.IsInstance, target.IsStatic, name, includeProtected)); DoAddIfMissingRange("Base Members:", items, m_database.GetMembers(baseNames.ToArray(), target.IsInstance, target.IsStatic, name, arity, includeProtected)); DoAddIfMissingRange("Interface Members:", items, m_database.GetMembers(interfaceNames.ToArray(), target.IsInstance, target.IsStatic, name, arity, includeProtected)); if (target.IsInstance) { var namespaces = new List<string>(); for (int i = 0; i < globals.Namespaces.Length; ++i) namespaces.Add(globals.Namespaces[i].Name); for (int i = 0; i < globals.Uses.Length; ++i) namespaces.Add(globals.Uses[i].Namespace); DoAddIfMissingRange("extension methods:", items, m_database.GetExtensionMethods(allNames, namespaces.ToArray(), name, arity)); } Profile.Stop("ResolveMembers::Find"); return items.ToArray(); }
private void DoBuildNewFile(string name, CsGlobalNamespace globals, CsDeclaration first, StringBuilder builder, string text, int offset, int length) { // If the file starts with a comment then write it out. if (text.Length > 2 && text[0] == '/' && text[1] == '/') DoWriteSingleLineComments(builder, text); else if (text.Length > 2 && text[0] == '/' && text[1] == '*') DoWriteDelimitedComment(builder, text); // Write the global using directives. DoWriteUsing(builder, globals, string.Empty); // Write the namespace the declaration was in. CsNamespace ns = DoGetNamespace(first); if (ns != null && ns.Name != "<globals>") { builder.WriteLine("namespace {0}{1}{2}", ns.Name, Constants.Bullet, "{"); DoWriteUsing(builder, ns, "\t"); } // If we're moving a member then create a dummy type. CsMember member = first as CsMember; if (member != null && member.DeclaringType != null) { string keyword = "?"; if (member.DeclaringType is CsClass) keyword = "class"; else if (member.DeclaringType is CsInterface) keyword = "interface"; else if (member.DeclaringType is CsStruct) keyword = "struct"; string modifiers; if (member.DeclaringType != null) modifiers = member.DeclaringType.Modifiers.ToString().ToLower(); else modifiers = member.Modifiers.ToString().ToLower(); modifiers = modifiers.Replace(",", string.Empty); builder.WriteLine("\t{0} {1} {2}", modifiers, keyword, name); builder.WriteLine("\t{"); } // Write the selection. builder.Write(text.Substring(offset, length)); // Close up type and namespaces. if (member != null && member.DeclaringType != null) builder.WriteLine("\t}"); if (ns != null && ns.Name != "<globals>") builder.WriteLine("}"); }
private void DoGetParsedExtensions(CsGlobalNamespace globals, string targetType, List<Item> items) { CsType[] types = DoGetAllParsedTypes(globals); foreach (CsType type in types) { foreach (CsMethod method in type.Methods) { if (method.IsExtension) { string fullName = DoGetFullParsedName(globals, method.Parameters[0].Type); if (targetType == fullName) { List<string> argTypes = (from p in method.Parameters select p.ModifiedType).ToList(); List<string> argNames = (from p in method.Parameters select p.Name).ToList(); argTypes.RemoveAt(0); argNames.RemoveAt(0); // TODO: should add gargs if they cannot be deduced items.AddIfMissing(new MethodItem(method.ReturnType, method.Name, null, argTypes.ToArray(), argNames.ToArray(), method.ReturnType, "extension methods")); } } } } }
private void DoGetParsedBases(CsGlobalNamespace globals, CsType type, List<string> baseNames, List<string> interfaceNames, List<string> allNames) { baseNames.AddIfMissing("System.Object"); allNames.AddIfMissing("System.Object"); foreach (string name in type.Bases.Names) { string fullName = DoGetFullParsedName(globals, name); if (fullName != null) { if (CsHelpers.IsInterface(fullName)) interfaceNames.AddIfMissing(fullName); else baseNames.AddIfMissing(fullName); allNames.AddIfMissing(fullName); } } }
private void DoAddRealTypes(List<Item> items, CsGlobalNamespace globals, string stem) { var namespaces = new List<string>(); DoAddParsedTypes(items, (string) null, stem); namespaces.AddIfMissing(string.Empty); for (int i = 0; i < globals.Namespaces.Length; ++i) { DoAddParsedTypes(items, globals.Namespaces[i].Name, stem); namespaces.AddIfMissing(globals.Namespaces[i].Name); } for (int i = 0; i < globals.Uses.Length; ++i) { DoAddParsedTypes(items, globals.Uses[i].Namespace, stem); namespaces.AddIfMissing(globals.Uses[i].Namespace); } items.AddIfMissingRange(m_database.GetStemmedTypes(namespaces.ToArray(), stem)); }
private string[] DoGetBases(CsGlobalNamespace globals, string typeName, List<CsType> types, List<string> baseNames, List<string> interfaceNames) { #if TEST var parses = new CsParser.Parses(); #else Boss boss = ObjectModel.Create("CsParser"); var parses = boss.Get<IParses>(); #endif var allNames = new List<string>(); allNames.Add(typeName); int i = 0; while (i < allNames.Count) { string name = allNames[i++]; // Note that we want to use CsType instead of the database where possible // because it should be more up to date. CsType type = parses.FindType(name); if (type != null) types.Add(type); if (type is CsEnum) { name = "System.Enum"; type = null; } // If the type is partial then the parsed types (probably) do not include all // of the items so we need to include both the parsed and database // info to ensure we get everything. if (type == null || (type.Modifiers & MemberModifiers.Partial) != 0) if (CsHelpers.IsInterface(name)) interfaceNames.AddIfMissing(name); else baseNames.AddIfMissing(name); if (type != null) DoGetParsedBases(globals, type, baseNames, interfaceNames, allNames); else m_database.GetBases(name, baseNames, interfaceNames, allNames); } return allNames.ToArray(); }
private CsType[] DoGetAllParsedTypes(CsGlobalNamespace globals) { var types = new List<CsType>(); #if !TEST types.AddRange(m_parses.FindTypes(null, string.Empty)); for (int i = 0; i < globals.Namespaces.Length; ++i) types.AddRange(m_parses.FindTypes(globals.Namespaces[i].Name, string.Empty)); for (int i = 0; i < globals.Uses.Length; ++i) types.AddRange(m_parses.FindTypes(globals.Uses[i].Namespace, string.Empty)); #endif return types.ToArray(); }
// Note that we take some pains to recover from parser errors. This is important // because they are quite common while code is being edited and we don't want // to lose all information about a type just because a brace is missing. public void TryParse(string text, out int offset, out int length, out CsGlobalNamespace globals, out Token[] tokens, out Token[] comments) { Contract.Requires(Thread.CurrentThread.ManagedThreadId == m_threadID, "can only be used with one thread"); m_try = true; m_bad = new Token(); try { DoInit(text); } catch (ScannerException e) { if (m_scanner != null) m_bad = m_scanner.Token; if (m_bad.Length == 0) m_bad = new Token(text, 0, 1, 1, TokenKind.Other); Log.WriteLine(TraceLevel.Verbose, "CsParser", "couldn't scan the first token: {0}", e.Message); } if (m_bad.Length == 0) globals = DoParseCompilationUnit(); else globals = null; if (m_bad.Length == 0) { offset = 0; length = 0; globals.Malformed = false; Log.WriteLine(TraceLevel.Verbose, "CsParser", "parsed ok"); } else { offset = m_bad.Offset; length = m_bad.Length; if (globals != null) globals.Malformed = true; Log.WriteLine(TraceLevel.Verbose, "CsParser", "{0} was bad at offset {1}", text.Substring(offset, length), offset); } comments = m_scanner.Comments; tokens = m_scanner.Tokens; }
private Item[] DoGetNames(CsGlobalNamespace globals, int location, string stem, ref bool isInstance, ref bool isStatic) { Profile.Start("AutoComplete::DoGetNames"); var result = new List<Item>(); var context = FindDeclaration(globals, location) as CsMember; var nameResolver = new ResolveName(context, m_database, m_locals, m_text.Text, location, globals); ResolvedTarget target = nameResolver.Resolve("<this>"); if (target != null) { var items = new List<Item>(m_members.Resolve(context, target, globals)); foreach (Variable v in nameResolver.Variables) { items.AddIfMissing(new NameItem(v.Name, v.Type + ' ' + v.Name, v.Filter, v.Type)); } if (stem.Length > 0) items.RemoveAll(m => !m.Text.StartsWith(stem)); result = items; isInstance = target.IsInstance; isStatic = target.IsStatic; } if (stem.Length > 0) { DoAddAliasedTypes(result, stem); DoAddRealTypes(result, globals, stem); } Profile.Stop("AutoComplete::DoGetNames"); return result.ToArray(); }
private Item[] DoGetConstructorsNamed(CsGlobalNamespace globals, ref string stem) { Profile.Start("AutoComplete::DoGetConstructorsNamed"); var items = new List<Item>(); var namespaces = new List<string>(); int j = stem.LastIndexOf('.'); if (j > 0) { string ns = stem.Substring(0, j); stem = stem.Substring(j + 1); DoAddConstructors(ns, stem, items); } else { DoAddConstructors(null, stem, items); namespaces.AddIfMissing(string.Empty); for (int i = 0; i < globals.Namespaces.Length; ++i) { DoAddConstructors(globals.Namespaces[i].Name, stem, items); namespaces.AddIfMissing(globals.Namespaces[i].Name); } for (int i = 0; i < globals.Uses.Length; ++i) { DoAddConstructors(globals.Uses[i].Namespace, stem, items); namespaces.AddIfMissing(globals.Uses[i].Namespace); } } items.AddIfMissingRange(m_database.GetStemmedCtors(namespaces.ToArray(), stem)); Profile.Stop("AutoComplete::DoGetConstructorsNamed"); return items.ToArray(); }
private Item[] DoGetAliasedConstructorsNamed(CsGlobalNamespace globals, string stem) { var items = new List<Item>(); foreach (string alias in CsHelpers.GetAliasedNames()) { if (alias.StartsWith(stem)) { string name = CsHelpers.GetRealName(alias); items.AddRange(DoGetConstructorsNamed(globals, ref name)); } } return items.ToArray(); }
public void AddParse(string key, CsGlobalNamespace globals) { var parse = new Parse(0, "test.cs", 0, 0, globals, new Token[0], new Token[0]); lock (m_mutex) { m_parses[key] = parse; } }
private object DoGetAttributes(CsGlobalNamespace globals) { return globals.Attributes; }
private string DoGetFullParsedName(CsGlobalNamespace globals, string inName) { string typeName = null; string name = DoGetRootName(inName); string candidate = name; if (DoHasType(candidate)) typeName = candidate; for (int i = 0; i < globals.Namespaces.Length && typeName == null; ++i) { candidate = globals.Namespaces[i].Name + "." + name; if (DoHasType(candidate)) typeName = candidate; } for (int i = 0; i < globals.Uses.Length && typeName == null; ++i) { candidate = globals.Uses[i].Namespace + "." + name; if (DoHasType(candidate)) typeName = candidate; } return typeName; }