public override void ApplyInterningProvider(IInterningProvider provider) { base.ApplyInterningProvider(provider); getter = provider.Intern(getter); setter = provider.Intern(setter); parameters = provider.InternList(parameters); }
public void AddMember(IUnresolvedEntity entity, Mono.Cecil.MemberReference cecilObject) { rwLock.EnterWriteLock(); try { uint token = cecilObject.MetadataToken.ToUInt32(); metadataTokens[entity] = token; var cecilMethod = cecilObject as Mono.Cecil.MethodDefinition; if (cecilMethod != null) { IUnresolvedMethod method = (IUnresolvedMethod)entity; tokenToMethod[token] = method; if (cecilMethod.HasBody) { var locals = cecilMethod.Body.Variables; if (locals.Count > 0) { localVariableTypes[method] = locals.Select(v => typeRefLoader.ReadTypeReference(v.VariableType)).ToArray(); } if (cecilMethod.RVA != 0) { // The method was loaded from image - we can free the memory for the body // because Cecil will re-initialize it on demand cecilMethod.Body = null; } } } } finally { rwLock.ExitWriteLock(); } }
public NUnitTestMethod(ITestProject parentProject, IUnresolvedMethod method, FullTypeName derivedFixture = default(FullTypeName)) { if (parentProject == null) throw new ArgumentNullException("parentProject"); this.parentProject = parentProject; UpdateTestMethod(method, derivedFixture); }
public override void ApplyInterningProvider(IInterningProvider provider) { base.ApplyInterningProvider(provider); addAccessor = provider.Intern(addAccessor); removeAccessor = provider.Intern(removeAccessor); invokeAccessor = provider.Intern(invokeAccessor); }
private static IMember ConvertToMember(IUnresolvedMember input) { IUnresolvedField field = input as IUnresolvedField; if (field != null) { return(new VB6Field(field)); } IUnresolvedMethod method = input as IUnresolvedMethod; if (method != null) { return(new VB6Method(method)); } IUnresolvedProperty property = input as IUnresolvedProperty; if (property != null) { return(new VB6Property(property)); } return(null); }
IEnumerable <IMethod> GetFilteredMethods(Predicate <IUnresolvedMethod> filter) { var members = GetMemberList(); for (int i = 0; i < members.unresolvedMembers.Length; i++) { IUnresolvedMethod unresolved = members.unresolvedMembers[i] as IUnresolvedMethod; if (unresolved != null && (filter == null || filter(unresolved))) { yield return((IMethod)members[i]); } } for (int i = members.unresolvedMembers.Length; i < members.Count; i++) { var method = (IMethod)members[i]; bool ok = false; foreach (var part in method.Parts) { if (filter == null || filter(part)) { ok = true; break; } } if (ok) { yield return(method); } } }
public DelegateDeclaration(TypeContainer parent, FullNamedExpression type, Modifiers mod_flags, MemberName name, ParametersCompiled param_list, VSharpAttributes attrs, CompilationSourceFile file) : base(parent, mod_flags | Modifiers.SEALED, AllowedModifiers, name, attrs, name.Location, TypeKind.Delegate, file) { BaseTypes.Add(KnownTypeReference.MulticastDelegate); this.ReturnType = type; parameters = param_list; List <IUnresolvedParameter> uparameters = new List <IUnresolvedParameter>(); foreach (Parameter p in param_list.parameters) { uparameters.Add(p); } AddDefaultMethodsToDelegate(type as ITypeReference, uparameters); if (attrs != null) { IUnresolvedMethod invokeMethod = (IUnresolvedMethod)Members.Single(m => m.Name == "Invoke"); foreach (IUnresolvedAttribute attr in attrs.Attrs.Where(x => x.ExplicitTarget == "ret").ToList()) { invokeMethod.ReturnTypeAttributes.Add(attr); } } }
public PartialMethodInfo(IUnresolvedMethod method, ITypeResolveContext context) { this.Name = method.Name; this.TypeParameterCount = method.TypeParameters.Count; this.Parameters = method.Parameters.CreateResolvedParameters(context); this.Parts.Add(method); this.Contexts.Add(context); }
public DefaultResolvedMethod(IUnresolvedMethod unresolved, ITypeResolveContext parentContext, bool isExtensionMethod) : base(unresolved, parentContext) { this.Parameters = unresolved.Parameters.CreateResolvedParameters(context); this.ReturnTypeAttributes = unresolved.ReturnTypeAttributes.CreateResolvedAttributes(parentContext); this.TypeParameters = unresolved.TypeParameters.CreateResolvedTypeParameters(context); this.IsExtensionMethod = isExtensionMethod; }
/// <summary> /// Gets the CompletionImage instance for the specified entity. /// Returns null when no image is available for the entity type. /// </summary> public static CompletionImage GetCompletionImage(IUnresolvedEntity entity) { if (entity == null) { throw new ArgumentNullException("entity"); } switch (entity.SymbolKind) { case SymbolKind.TypeDefinition: return(GetCompletionImageForType(((IUnresolvedTypeDefinition)entity).Kind, entity.IsStatic)); case SymbolKind.Field: IUnresolvedField field = (IUnresolvedField)entity; if (field.IsConst) { if (field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Kind == TypeKind.Enum) { return(imageEnumValue); } else { return(imageLiteral); } } return(field.IsReadOnly ? imageFieldReadOnly : imageField); case SymbolKind.Method: IUnresolvedMethod method = (IUnresolvedMethod)entity; // We cannot reliably detect extension methods in the unresolved type system (e.g. in VB we need to resolve an attribute), // but at least we can do it for C#: var defMethod = method as DefaultUnresolvedMethod; if (defMethod != null && defMethod.IsExtensionMethod) { return(imageExtensionMethod); } return(method.IsOverridable ? imageVirtualMethod : imageMethod); case SymbolKind.Property: return(imageProperty); case SymbolKind.Indexer: return(imageIndexer); case SymbolKind.Event: return(imageEvent); case SymbolKind.Operator: case SymbolKind.Destructor: return(imageOperator); case SymbolKind.Constructor: return(imageConstructor); default: return(null); } }
public NUnitTestMethod(ITestProject parentProject, IUnresolvedMethod method, FullTypeName derivedFixture = default(FullTypeName)) { if (parentProject == null) { throw new ArgumentNullException("parentProject"); } this.parentProject = parentProject; UpdateTestMethod(method, derivedFixture); }
public void AddPart(IUnresolvedMethod method, ITypeResolveContext context) { if (method.IsPartialMethodImplementation) { // make the implementation the primary part this.Parts.Insert(0, method); this.PrimaryContext = context; } else { this.Parts.Add(method); } }
MethodDefinition GetCecilObject(IUnresolvedMethod method) { object cecilObj; if (unresolvedTypeSystemToCecilDict.TryGetValue(method, out cecilObj)) { return(cecilObj as MethodDefinition); } else { return(null); } }
/// <summary> /// Gets the CompletionImage instance for the specified entity. /// Returns null when no image is available for the entity type. /// </summary> public static CompletionImage GetCompletionImage(IUnresolvedEntity entity) { if (entity == null) { throw new ArgumentNullException("entity"); } switch (entity.SymbolKind) { case SymbolKind.TypeDefinition: return(GetCompletionImageForType(((IUnresolvedTypeDefinition)entity).Kind, entity.IsStatic)); case SymbolKind.Field: IUnresolvedField field = (IUnresolvedField)entity; if (field.IsConst) { if (field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Kind == TypeKind.Enum) { return(imageEnumValue); } else { return(imageLiteral); } } return(field.IsReadOnly ? imageFieldReadOnly : imageField); case SymbolKind.Method: IUnresolvedMethod method = (IUnresolvedMethod)entity; return(method.IsOverridable ? imageVirtualMethod : imageMethod); case SymbolKind.Property: return(imageProperty); case SymbolKind.Indexer: return(imageIndexer); case SymbolKind.Event: return(imageEvent); case SymbolKind.Operator: case SymbolKind.Destructor: return(imageOperator); case SymbolKind.Constructor: return(imageConstructor); default: return(null); } }
public void AddPart(IUnresolvedMethod method, ITypeResolveContext context) { if (method.HasBody) { // make the implementation the primary part this.Parts.Insert(0, method); this.Contexts.Insert(0, context); } else { this.Parts.Add(method); this.Contexts.Add(context); } }
public void UpdateTestMethod(IUnresolvedMethod method, FullTypeName derivedFixture = default(FullTypeName)) { if (method == null) throw new ArgumentNullException("method"); string oldDisplayName = this.displayName; this.derivedFixture = derivedFixture; this.method = method; if (this.IsInherited) displayName = method.DeclaringTypeDefinition.Name + "." + method.Name; else displayName = method.Name; if (displayName != oldDisplayName && DisplayNameChanged != null) DisplayNameChanged(this, EventArgs.Empty); }
internal static IConstantValue ConvertConstantValue( ITypeReference targetType, AstNode expression, IUnresolvedTypeDefinition parentTypeDefinition, IUnresolvedMethod parentMethodDefinition, UsingScope parentUsingScope) { ConstantValueBuilder b = new ConstantValueBuilder(false); ConstantExpression c = expression.AcceptVisitor(b, null); if (c == null) return new ErrorConstantValue(targetType); PrimitiveConstantExpression pc = c as PrimitiveConstantExpression; if (pc != null && pc.Type == targetType) { // Save memory by directly using a SimpleConstantValue. return new SimpleConstantValue(targetType, pc.Value); } // cast to the desired type return new ConstantCast(targetType, c); }
internal IMethod GetAccessor(ref IMethod accessorField, IUnresolvedMethod unresolvedAccessor) { if (unresolvedAccessor == null) { return(null); } IMethod result = LazyInit.VolatileRead(ref accessorField); if (result != null) { return(result); } else { return(LazyInit.GetOrSet(ref accessorField, (IMethod)unresolvedAccessor.CreateResolved(context))); } }
static void AddPlaceholders(Step action, IUnresolvedMethod method) { var parameters = new List <IUnresolvedParameter> (); int index = 0; foreach (var placeholder in action.Placeholders) { var typeRef = new DefaultUnresolvedTypeDefinition(placeholder.Name); var p = new DefaultUnresolvedParameter(typeRef, "p" + index); method.Parameters.Add(p); index++; } }
public void Parse_ModuleWithOneClassThatHasOneMethod_NestedClassHasOneMethod() { string code = "module MyModule {\r\n" + " class Student {\r\n" + " speak() {\r\n" + " }\r\n" + " }\r\n" + "}\r\n"; Parse(code); IUnresolvedTypeDefinition module = GetFirstClass(); IUnresolvedTypeDefinition c = module.NestedTypes.FirstOrDefault(); IUnresolvedMethod method = c.Methods.First(); Assert.AreEqual("speak", method.Name); }
public void Parse_ClassWithOneMethod_ClassHasOneMethodWithCorrectBodyRegionAndName() { string code = "class Student {\r\n" + " sayHello() {\r\n" + " return \"Hello\";\r\n" + " }\r\n" + "}\r\n"; Parse(code); IUnresolvedTypeDefinition c = GetFirstClass(); IUnresolvedMethod method = c.Methods.First(); Assert.AreEqual("sayHello", method.Name); Assert.AreEqual(2, method.Region.EndLine); Assert.AreEqual(15, method.Region.EndColumn); Assert.AreEqual(4, method.BodyRegion.EndLine); Assert.AreEqual(6, method.BodyRegion.EndColumn); }
public void Parse_ClassWithConstructor_ClassHasOneConstructorMethodWithCorrectBodyRegionAndName() { string code = "class Student {\r\n" + " constructor() {\r\n" + " \r\n" + " }\r\n" + "}\r\n"; Parse(code); IUnresolvedTypeDefinition c = GetFirstClass(); IUnresolvedMethod method = c.Methods.First(); Assert.AreEqual("constructor", method.Name); Assert.AreEqual(2, method.Region.EndLine); Assert.AreEqual(18, method.Region.EndColumn); Assert.AreEqual(4, method.BodyRegion.EndLine); Assert.AreEqual(6, method.BodyRegion.EndColumn); }
MemberList GetMemberList() { var result = LazyInit.VolatileRead(ref this.memberList); if (result != null) { return(result); } List <IUnresolvedMember> unresolvedMembers = new List <IUnresolvedMember>(); List <ITypeResolveContext> contextPerMember = new List <ITypeResolveContext>(); bool addDefaultConstructorIfRequired = false; foreach (IUnresolvedTypeDefinition part in parts) { ITypeResolveContext parentContextForPart = part.CreateResolveContext(parentContext); ITypeResolveContext contextForPart = parentContextForPart.WithCurrentTypeDefinition(this); foreach (var member in part.Members) { IUnresolvedMethod method = member as IUnresolvedMethod; unresolvedMembers.Add(member); contextPerMember.Add(contextForPart); } addDefaultConstructorIfRequired |= part.AddDefaultConstructorIfRequired; } if (addDefaultConstructorIfRequired) { TypeKind kind = this.Kind; if (kind == TypeKind.Class && !this.IsStatic && !unresolvedMembers.Any(m => m.SymbolKind == SymbolKind.Constructor && !m.IsStatic) || kind == TypeKind.Enum || kind == TypeKind.Struct) { contextPerMember.Add(parts[0].CreateResolveContext(parentContext).WithCurrentTypeDefinition(this)); unresolvedMembers.Add(MethodCore.CreateDefaultConstructor(parts[0])); } } result = new MemberList(contextPerMember, unresolvedMembers); return(LazyInit.GetOrSet(ref this.memberList, result)); }
public override IUnresolvedEntity VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) { var td = currentTypeDefinition = CreateTypeDefinition(delegateDeclaration.Name); td.Kind = TypeKind.Delegate; td.Region = MakeRegion(delegateDeclaration); td.BaseTypes.Add(KnownTypeReference.MulticastDelegate); ApplyModifiers(td, delegateDeclaration.Modifiers); td.IsSealed = true; // delegates are implicitly sealed ConvertTypeParameters(td.TypeParameters, delegateDeclaration.TypeParameters, delegateDeclaration.Constraints, EntityType.TypeDefinition); ITypeReference returnType = delegateDeclaration.ReturnType.ToTypeReference(); List<IUnresolvedParameter> parameters = new List<IUnresolvedParameter>(); ConvertParameters(parameters, delegateDeclaration.Parameters); AddDefaultMethodsToDelegate(td, returnType, parameters); foreach (AttributeSection section in delegateDeclaration.Attributes) { if (section.AttributeTarget == "return") { List<IUnresolvedAttribute> returnTypeAttributes = new List<IUnresolvedAttribute>(); ConvertAttributes(returnTypeAttributes, section); IUnresolvedMethod invokeMethod = (IUnresolvedMethod)td.Members.Single(m => m.Name == "Invoke"); IUnresolvedMethod endInvokeMethod = (IUnresolvedMethod)td.Members.Single(m => m.Name == "EndInvoke"); foreach (IUnresolvedAttribute attr in returnTypeAttributes) { invokeMethod.ReturnTypeAttributes.Add(attr); endInvokeMethod.ReturnTypeAttributes.Add(attr); } } else { ConvertAttributes(td.Attributes, section); } } currentTypeDefinition = (CSharpUnresolvedTypeDefinition)currentTypeDefinition.DeclaringTypeDefinition; if (interningProvider != null) { td.ApplyInterningProvider(interningProvider); } return td; }
public void UpdateTestMethod(IUnresolvedMethod method, FullTypeName derivedFixture = default(FullTypeName)) { if (method == null) { throw new ArgumentNullException("method"); } string oldDisplayName = this.displayName; this.derivedFixture = derivedFixture; this.method = method; if (this.IsInherited) { displayName = method.DeclaringTypeDefinition.Name + "." + method.Name; } else { displayName = method.Name; } if (displayName != oldDisplayName && DisplayNameChanged != null) { DisplayNameChanged(this, EventArgs.Empty); } }
public void Parse_TwoClassesAndSecondOneHasOneMethod_SecondClassHasOneMethodWithCorrectBodyRegionAndName() { string code = "class Class1 {\r\n" + "}\r\n" + "\r\n" + "class Class2 {\r\n" + " sayHello() {\r\n" + " return \"Hello\";\r\n" + " }\r\n" + "}\r\n"; Parse(code); IUnresolvedTypeDefinition c = GetSecondClass(); IUnresolvedMethod method = c.Methods.FirstOrDefault(); Assert.AreEqual(2, ParseInfo.UnresolvedFile.TopLevelTypeDefinitions.Count); Assert.AreEqual("sayHello", method.Name); Assert.AreEqual(5, method.Region.EndLine); Assert.AreEqual(15, method.Region.EndColumn); Assert.AreEqual(7, method.BodyRegion.EndLine); Assert.AreEqual(6, method.BodyRegion.EndColumn); }
MemberList GetMemberList() { var result = LazyInit.VolatileRead(ref this.memberList); if (result != null) { return(result); } List <IUnresolvedMember> unresolvedMembers = new List <IUnresolvedMember>(); List <ITypeResolveContext> contextPerMember = new List <ITypeResolveContext>(); List <PartialMethodInfo> partialMethodInfos = null; bool addDefaultConstructorIfRequired = false; foreach (IUnresolvedTypeDefinition part in parts) { ITypeResolveContext parentContextForPart = part.CreateResolveContext(parentContext); ITypeResolveContext contextForPart = parentContextForPart.WithCurrentTypeDefinition(this); foreach (var member in part.Members) { IUnresolvedMethod method = member as IUnresolvedMethod; if (method != null && method.IsPartial) { // Merge partial method declaration and implementation if (partialMethodInfos == null) { partialMethodInfos = new List <PartialMethodInfo>(); } PartialMethodInfo newInfo = new PartialMethodInfo(method, contextForPart); PartialMethodInfo existingInfo = null; foreach (var info in partialMethodInfos) { if (newInfo.IsSameSignature(info, Compilation.NameComparer)) { existingInfo = info; break; } } if (existingInfo != null) { // Add the unresolved method to the PartialMethodInfo: existingInfo.AddPart(method, contextForPart); } else { partialMethodInfos.Add(newInfo); } } else { unresolvedMembers.Add(member); contextPerMember.Add(contextForPart); } } addDefaultConstructorIfRequired |= part.AddDefaultConstructorIfRequired; } if (addDefaultConstructorIfRequired) { TypeKind kind = this.Kind; if (kind == TypeKind.Class && !this.IsStatic && !unresolvedMembers.Any(m => m.SymbolKind == SymbolKind.Constructor && !m.IsStatic) || kind == TypeKind.Enum || kind == TypeKind.Struct) { contextPerMember.Add(parts[0].CreateResolveContext(parentContext).WithCurrentTypeDefinition(this)); unresolvedMembers.Add(DefaultUnresolvedMethod.CreateDefaultConstructor(parts[0])); } } result = new MemberList(contextPerMember, unresolvedMembers, partialMethodInfos); return(LazyInit.GetOrSet(ref this.memberList, result)); }
public static DefaultResolvedMethod CreateFromMultipleParts(IUnresolvedMethod[] parts, ITypeResolveContext firstPartParentContext, bool isExtensionMethod) { DefaultResolvedMethod method = new DefaultResolvedMethod(parts[0], firstPartParentContext, isExtensionMethod); method.parts = parts; return method; }
internal IMethod GetAccessor(ref IMethod accessorField, IUnresolvedMethod unresolvedAccessor) { if (unresolvedAccessor == null) return null; IMethod result = accessorField; if (result != null) { LazyInit.ReadBarrier(); return result; } else { return LazyInit.GetOrSet(ref accessorField, (IMethod)unresolvedAccessor.CreateResolved(context)); } }
static void AddPlaceholders(Step action, IUnresolvedMethod method) { var parameters = new List<IUnresolvedParameter> (); int index = 0; foreach (var placeholder in action.Placeholders) { var typeRef = new DefaultUnresolvedTypeDefinition (placeholder.Name); var p = new DefaultUnresolvedParameter (typeRef, "p" + index); method.Parameters.Add (p); index++; } }
internal IMethod GetAccessor(ref IMethod accessorField, IUnresolvedMethod unresolvedAccessor) { if (unresolvedAccessor == null) return null; IMethod result = LazyInit.VolatileRead(ref accessorField); if (result != null) { return result; } else { return LazyInit.GetOrSet(ref accessorField, CreateResolvedAccessor(unresolvedAccessor)); } }
void FormatLineInternal(ITextEditor textArea, int lineNr, int cursorOffset, char ch) { IDocumentLine curLine = textArea.Document.GetLineByNumber(lineNr); IDocumentLine lineAbove = lineNr > 1 ? textArea.Document.GetLineByNumber(lineNr - 1) : null; string terminator = DocumentUtilities.GetLineTerminator(textArea.Document, lineNr); string curLineText; // local string for curLine segment if (ch == '/') { curLineText = textArea.Document.GetText(curLine); string lineAboveText = lineAbove == null ? "" : textArea.Document.GetText(lineAbove); if (curLineText != null && curLineText.EndsWith("///", StringComparison.Ordinal) && (lineAboveText == null || !lineAboveText.Trim().StartsWith("///", StringComparison.Ordinal))) { string indentation = DocumentUtilities.GetWhitespaceAfter(textArea.Document, curLine.Offset); IUnresolvedEntity member = GetMemberAfter(textArea, lineNr); if (member != null) { StringBuilder sb = new StringBuilder(); sb.Append(" <summary>"); sb.Append(terminator); sb.Append(indentation); sb.Append("/// "); sb.Append(terminator); sb.Append(indentation); sb.Append("/// </summary>"); IUnresolvedMethod method = null; if (member is IUnresolvedMethod) { method = (IUnresolvedMethod)member; } else if (member is IUnresolvedTypeDefinition) { IUnresolvedTypeDefinition type = (IUnresolvedTypeDefinition)member; if (type.Kind == TypeKind.Delegate) { method = type.Methods.FirstOrDefault(m => m.Name == "Invoke"); } } if (method != null) { for (int i = 0; i < method.Parameters.Count; ++i) { sb.Append(terminator); sb.Append(indentation); sb.Append("/// <param name=\""); sb.Append(method.Parameters[i].Name); sb.Append("\"></param>"); } if (!method.IsConstructor) { KnownTypeReference returnType = method.ReturnType as KnownTypeReference; if (returnType == null || returnType.KnownTypeCode != KnownTypeCode.Void) { sb.Append(terminator); sb.Append(indentation); sb.Append("/// <returns></returns>"); } } } textArea.Document.Insert(cursorOffset, sb.ToString()); textArea.Caret.Offset = cursorOffset + indentation.Length + "/// ".Length + " <summary>".Length + terminator.Length; } } return; } if (ch != '\n' && ch != '>') { if (IsInsideStringOrComment(textArea, curLine, cursorOffset)) { return; } } switch (ch) { case '>': if (IsInsideDocumentationComment(textArea, curLine, cursorOffset)) { curLineText = textArea.Document.GetText(curLine); int column = cursorOffset - curLine.Offset; int index = Math.Min(column - 1, curLineText.Length - 1); while (index >= 0 && curLineText[index] != '<') { --index; if (curLineText[index] == '/') { return; // the tag was an end tag or already } } if (index > 0) { StringBuilder commentBuilder = new StringBuilder(""); for (int i = index; i < curLineText.Length && i < column && !Char.IsWhiteSpace(curLineText[i]); ++i) { commentBuilder.Append(curLineText[i]); } string tag = commentBuilder.ToString().Trim(); if (!tag.EndsWith(">", StringComparison.Ordinal)) { tag += ">"; } if (!tag.StartsWith("/", StringComparison.Ordinal)) { textArea.Document.Insert(cursorOffset, "</" + tag.Substring(1), AnchorMovementType.BeforeInsertion); } } } break; case ':': case ')': case ']': case '{': //if (textArea.Document.TextEditorProperties.IndentStyle == IndentStyle.Smart) { IndentLine(textArea, curLine); //} break; case '}': // Try to get corresponding block beginning brace var bracketSearchResult = textArea.Language.BracketSearcher.SearchBracket(textArea.Document, cursorOffset); if (bracketSearchResult != null) { // Format the block if (!FormatStatement(textArea, cursorOffset, bracketSearchResult.OpeningBracketOffset)) { // No auto-formatting seems to be active, at least indent the line IndentLine(textArea, curLine); } } break; case ';': // Format this line if (!FormatStatement(textArea, cursorOffset, cursorOffset)) { // No auto-formatting seems to be active, at least indent the line IndentLine(textArea, curLine); } break; case '\n': string lineAboveText = lineAbove == null ? "" : textArea.Document.GetText(lineAbove); // curLine might have some text which should be added to indentation curLineText = textArea.Document.GetText(curLine); if (lineAboveText != null && lineAboveText.Trim().StartsWith("#region", StringComparison.Ordinal) && NeedEndregion(textArea.Document)) { textArea.Document.Insert(cursorOffset, "#endregion"); return; } IHighlighter highlighter = textArea.GetService(typeof(IHighlighter)) as IHighlighter; bool isInMultilineComment = false; bool isInMultilineString = false; if (highlighter != null && lineAbove != null) { var spanStack = highlighter.GetColorStack(lineNr).Select(c => c.Name).ToArray(); isInMultilineComment = spanStack.Contains(HighlighterKnownSpanNames.Comment); isInMultilineString = spanStack.Contains(HighlighterKnownSpanNames.String); } bool isInNormalCode = !(isInMultilineComment || isInMultilineString); if (lineAbove != null && isInMultilineComment) { string lineAboveTextTrimmed = lineAboveText.TrimStart(); if (lineAboveTextTrimmed.StartsWith("/*", StringComparison.Ordinal)) { textArea.Document.Insert(cursorOffset, " * "); return; } if (lineAboveTextTrimmed.StartsWith("*", StringComparison.Ordinal)) { textArea.Document.Insert(cursorOffset, "* "); return; } } if (lineAbove != null && isInNormalCode) { IDocumentLine nextLine = lineNr + 1 <= textArea.Document.LineCount ? textArea.Document.GetLineByNumber(lineNr + 1) : null; string nextLineText = (nextLine != null) ? textArea.Document.GetText(nextLine) : ""; int indexAbove = lineAboveText.IndexOf("///", StringComparison.Ordinal); int indexNext = nextLineText.IndexOf("///", StringComparison.Ordinal); if (indexAbove > 0 && (indexNext != -1 || indexAbove + 4 < lineAbove.Length)) { textArea.Document.Insert(cursorOffset, "/// "); return; } if (IsInNonVerbatimString(lineAboveText, curLineText)) { textArea.Document.Insert(cursorOffset, "\""); textArea.Document.Insert(lineAbove.Offset + lineAbove.Length, "\" +"); } } if (textArea.Options.AutoInsertBlockEnd && lineAbove != null && isInNormalCode) { string oldLineText = textArea.Document.GetText(lineAbove); if (oldLineText.EndsWith("{", StringComparison.Ordinal)) { if (NeedCurlyBracket(textArea.Document.Text)) { int insertionPoint = curLine.Offset + curLine.Length; textArea.Document.Insert(insertionPoint, terminator + "}"); IndentLine(textArea, textArea.Document.GetLineByNumber(lineNr + 1)); textArea.Caret.Offset = insertionPoint; } } } return; } }
public AnonymousTypeAccessor(IUnresolvedMethod unresolved, ITypeResolveContext parentContext, AnonymousTypeProperty owner) : base(unresolved, parentContext, isExtensionMethod: false) { this.owner = owner; }
protected override IMethod CreateResolvedAccessor(IUnresolvedMethod unresolvedAccessor) { return(new AnonymousTypeAccessor(unresolvedAccessor, context, this)); }
protected virtual IMethod CreateResolvedAccessor(IUnresolvedMethod unresolvedAccessor) { return (IMethod)unresolvedAccessor.CreateResolved(context); }
protected override IMethod CreateResolvedAccessor(IUnresolvedMethod unresolvedAccessor) { return new AnonymousTypeAccessor(unresolvedAccessor, context, this); }
MethodDefinition GetCecilObject(IUnresolvedMethod method) { object cecilObj; if (unresolvedTypeSystemToCecilDict.TryGetValue(method, out cecilObj)) { return cecilObj as MethodDefinition; } else { return null; } }
bool MatchDelegate(IType delegateType, IUnresolvedMethod method) { var delegateMethod = delegateType.GetDelegateInvokeMethod(); if (delegateMethod == null || delegateMethod.Parameters.Count != method.Parameters.Count) { return false; } for (int i = 0; i < delegateMethod.Parameters.Count; i++) { if (!delegateMethod.Parameters [i].Type.Equals(method.Parameters [i].Type.Resolve(ctx))) { return false; } } return true; }
protected virtual IMethod CreateResolvedAccessor(IUnresolvedMethod unresolvedAccessor) { return((IMethod)unresolvedAccessor.CreateResolved(context)); }
IMethod GetImplementation(ITypeDefinition type, IUnresolvedMethod method) { foreach (var cur in type.Methods) { if (cur.Name == method.Name && cur.Parameters.Count == method.Parameters.Count && !cur.BodyRegion.IsEmpty) { bool equal = true; /* for (int i = 0; i < cur.Parameters.Count; i++) { if (!cur.Parameters [i].Type.Equals (method.Parameters [i].Type)) { equal = false; break; } }*/ if (equal) { return cur; } } } return null; }
public void UpdateTestClass(ITypeDefinition typeDefinition) { fullTypeName = typeDefinition.FullTypeName; if (this.NestedTestsInitialized) { int baseClassIndex = 0; foreach (IType baseType in typeDefinition.GetNonInterfaceBaseTypes()) { ITypeDefinition baseTypeDef = baseType.GetDefinition(); // Check that the base type isn't equal to System.Object or the current class itself if (baseTypeDef == null || baseTypeDef == typeDefinition || baseTypeDef.KnownTypeCode == KnownTypeCode.Object) { continue; } if (baseTypeDef.DeclaringTypeDefinition != null) { continue; // we only support inheriting from top-level classes } var baseClassName = baseTypeDef.FullTypeName; if (baseClassIndex < baseClassNames.Count && baseClassName == baseClassNames[baseClassIndex]) { // base class is already in the list, just keep it baseClassIndex++; } else { // base class is not in the list, or the remaining portion of the list differs // remove remaining portion of the list: RemoveBaseClasses(baseClassIndex); // Add new base class: parentProject.RegisterInheritedClass(baseClassName, this); baseClassNames.Add(baseClassName); baseClassIndex++; } } HashSet <ITest> newOrUpdatedNestedTests = new HashSet <ITest>(); // Update nested test classes: foreach (ITypeDefinition nestedClass in typeDefinition.NestedTypes) { if (!NUnitTestFramework.IsTestClass(nestedClass)) { continue; } NUnitTestClass nestedTestClass = FindNestedTestClass(nestedClass.Name, nestedClass.TypeParameterCount); if (nestedTestClass != null) { nestedTestClass.UpdateTestClass(nestedClass); } else { nestedTestClass = new NUnitTestClass(parentProject, nestedClass.FullTypeName); this.NestedTestCollection.Add(nestedTestClass); } newOrUpdatedNestedTests.Add(nestedTestClass); } // Get methods (not operators etc.) foreach (IMethod method in typeDefinition.GetMethods(m => m.SymbolKind == SymbolKind.Method)) { if (!NUnitTestFramework.IsTestMethod(method)) { continue; } IUnresolvedMethod unresolvedMethod = (IUnresolvedMethod)method.UnresolvedMember; string methodNameWithDeclaringType; FullTypeName derivedFixture; if (method.DeclaringTypeDefinition == typeDefinition) { derivedFixture = default(FullTypeName); // method is not inherited methodNameWithDeclaringType = method.Name; } else { if (method.DeclaringTypeDefinition == null) { continue; } derivedFixture = fullTypeName; // method is inherited methodNameWithDeclaringType = method.DeclaringTypeDefinition.Name + "." + method.Name; } NUnitTestMethod testMethod; if (method.IsOverride) { testMethod = FindTestMethodWithShortName(method.Name); } else { testMethod = FindTestMethod(methodNameWithDeclaringType); } if (testMethod != null) { testMethod.UpdateTestMethod(unresolvedMethod, derivedFixture); } else { testMethod = new NUnitTestMethod(parentProject, unresolvedMethod, derivedFixture); this.NestedTestCollection.Add(testMethod); } newOrUpdatedNestedTests.Add(testMethod); } // Remove all tests that weren't contained in the new type definition anymore: this.NestedTestCollection.RemoveAll(t => !newOrUpdatedNestedTests.Contains(t)); } }