internal virtual CustomAttributesBag <CSharpAttributeData> GetAttributesBag() { if (_lazyCustomAttributesBag == null || !_lazyCustomAttributesBag.IsSealed) { bool lazyAttributesStored = false; var sourceMethod = this.ContainingSymbol as SourceOrdinaryMethodSymbol; if ((object)sourceMethod == null || (object)sourceMethod.SourcePartialDefinition == null) { lazyAttributesStored = LoadAndValidateAttributes( OneOrMany.Create(this.MergedAttributeDeclarationSyntaxLists), ref _lazyCustomAttributesBag, binderOpt: (ContainingSymbol as LocalFunctionSymbol)?.SignatureBinder); } else { var typeParameter = (SourceTypeParameterSymbolBase)sourceMethod.SourcePartialDefinition.TypeParameters[_ordinal]; CustomAttributesBag <CSharpAttributeData> attributesBag = typeParameter.GetAttributesBag(); lazyAttributesStored = Interlocked.CompareExchange(ref _lazyCustomAttributesBag, attributesBag, null) == null; } if (lazyAttributesStored) { _state.NotePartComplete(CompletionPart.Attributes); } } return(_lazyCustomAttributesBag); }
internal override OneOrMany <SyntaxList <AttributeListSyntax> > GetReturnTypeAttributeDeclarations() { // BeginInvoke method doesn't have return type attributes // because it doesn't inherit Delegate declaration's return type. // It has a special return type: SpecialType.System.IAsyncResult. return(OneOrMany.Create(default(SyntaxList <AttributeListSyntax>))); }
internal override CustomAttributesBag <CSharpAttributeData> GetAttributesBag() { if (lazyCustomAttributesBag == null || !lazyCustomAttributesBag.IsSealed) { bool lazyAttributesStored = false; var sourceMethod = this.ContainingSymbol as SourceMemberMethodSymbol; if ((object)sourceMethod == null || (object)sourceMethod.SourcePartialDefinition == null) { lazyAttributesStored = LoadAndValidateAttributes(OneOrMany.Create(this.MergedAttributeDeclarationSyntaxLists), ref lazyCustomAttributesBag); } else { var typeParameter = (SourceTypeParameterSymbolBase)sourceMethod.SourcePartialDefinition.TypeParameters[this.ordinal]; CustomAttributesBag <CSharpAttributeData> attributesBag = typeParameter.GetAttributesBag(); lazyAttributesStored = Interlocked.CompareExchange(ref lazyCustomAttributesBag, attributesBag, null) == null; } if (lazyAttributesStored) { state.NotePartComplete(CompletionPart.Attributes); } } return(lazyCustomAttributesBag); }
public void SelectWithArg() { Verify(OneOrMany.Create(1).Select((i, a) => i + a, 1), 2); Verify(OneOrMany.Create(ImmutableArray <int> .Empty).Select((i, a) => i + a, 1)); Verify(OneOrMany.Create(ImmutableArray.Create(1)).Select((i, a) => i + a, 1), 2); Verify(OneOrMany.Create(ImmutableArray.Create(1, 2)).Select((i, a) => i + a, 1), 2, 3); }
public void Select() { Verify(OneOrMany.Create(1).Select(i => i + 1), 2); Verify(OneOrMany.Create(ImmutableArray <int> .Empty).Select(i => i + 1)); Verify(OneOrMany.Create(ImmutableArray.Create(1)).Select(i => i + 1), 2); Verify(OneOrMany.Create(ImmutableArray.Create(1, 2)).Select(i => i + 1), 2, 3); }
> GetAttributeDeclarations() { // TODO: This implementation looks strange. It might make sense for the Invoke method, but // not for constructor and other methods. return OneOrMany.Create( ((SourceNamedTypeSymbol)ContainingSymbol).GetAttributeDeclarations() ); }
public void Many() { Verify(OneOrMany.Create(ImmutableArray.Create(1, 2, 3)).Add(4), 1, 2, 3, 4); Verify(OneOrMany.Create(ImmutableArray.Create(1, 2, 3, 4)), 1, 2, 3, 4); Verify(OneOrMany.Create(ImmutableArray <int> .Empty).Add(1).Add(2).Add(3).Add(4), 1, 2, 3, 4); Verify(new OneOrMany <int>(ImmutableArray.Create(1, 2, 3)).Add(4), 1, 2, 3, 4); Verify(new OneOrMany <int>(ImmutableArray.Create(1, 2, 3, 4)), 1, 2, 3, 4); Verify(new OneOrMany <int>(ImmutableArray <int> .Empty).Add(1).Add(2).Add(3).Add(4), 1, 2, 3, 4); }
public void One() { Verify(OneOrMany.Create(1), 1); Verify(OneOrMany.Create(ImmutableArray.Create(2)), 2); Verify(OneOrMany.Create(ImmutableArray <int> .Empty).Add(3), 3); Verify(new OneOrMany <int>(1), 1); Verify(new OneOrMany <int>(ImmutableArray.Create(2)), 2); Verify(new OneOrMany <int>(ImmutableArray <int> .Empty).Add(3), 3); }
public void Add(AssemblyIdentity identity, TValue value) { var pair = KeyValuePairUtil.Create(identity, value); OneOrMany <KeyValuePair <AssemblyIdentity, TValue> > sameName; _map[identity.Name] = _map.TryGetValue(identity.Name, out sameName) ? sameName.Add(pair) : OneOrMany.Create(pair); }
public void FirstOrDefault() { Assert.Equal(1, OneOrMany.Create(1).FirstOrDefault(i => i < 2)); Assert.Equal(0, OneOrMany.Create(1).FirstOrDefault(i => i > 2)); Assert.Equal(0, OneOrMany.Create(ImmutableArray <int> .Empty).FirstOrDefault(i => i > 2)); Assert.Equal(1, OneOrMany.Create(ImmutableArray.Create(1)).FirstOrDefault(i => i < 2)); Assert.Equal(0, OneOrMany.Create(ImmutableArray.Create(1)).FirstOrDefault(i => i > 2)); Assert.Equal(1, OneOrMany.Create(ImmutableArray.Create(1, 3)).FirstOrDefault(i => i < 2)); Assert.Equal(3, OneOrMany.Create(ImmutableArray.Create(1, 3)).FirstOrDefault(i => i > 2)); }
internal override OneOrMany <SyntaxList <AttributeListSyntax> > GetAttributeDeclarations() { if ((object)this.SourcePartialImplementation != null) { return(OneOrMany.Create(ImmutableArray.Create(AttributeDeclarationSyntaxList, this.SourcePartialImplementation.AttributeDeclarationSyntaxList))); } else { return(OneOrMany.Create(AttributeDeclarationSyntaxList)); } }
public void Errors() { var single = OneOrMany.Create(123); var quad = OneOrMany.Create(ImmutableArray.Create <int>(10, 20, 30, 40)); Assert.Throws <IndexOutOfRangeException>(() => single[1]); Assert.Throws <IndexOutOfRangeException>(() => single[-1]); Assert.Throws <IndexOutOfRangeException>(() => quad[5]); Assert.Throws <IndexOutOfRangeException>(() => quad[-1]); Assert.Throws <ArgumentNullException>(() => OneOrMany.Create(default(ImmutableArray <int>))); }
internal override OneOrMany <SyntaxList <AttributeListSyntax> > GetAttributeDeclarations() { var syntax = this.SyntaxNode; switch (syntax.Kind) { case SyntaxKind.GetAccessorDeclaration: case SyntaxKind.SetAccessorDeclaration: return(OneOrMany.Create(((AccessorDeclarationSyntax)syntax).AttributeLists)); } return(base.GetAttributeDeclarations()); }
/// <summary> /// Returns a bag of applied custom attributes and data decoded from well-known attributes. Returns null if there are no attributes applied on the symbol. /// </summary> /// <remarks> /// Forces binding and decoding of attributes. /// </remarks> private CustomAttributesBag <CSharpAttributeData> GetAttributesBag() { if ((_lazyCustomAttributesBag == null || !_lazyCustomAttributesBag.IsSealed) && LoadAndValidateAttributes(OneOrMany.Create(this.AttributeDeclarationSyntaxList), ref _lazyCustomAttributesBag)) { DeclaringCompilation.SymbolDeclaredEvent(this); var wasCompletedThisThread = state.NotePartComplete(CompletionPart.Attributes); Debug.Assert(wasCompletedThisThread); } return(_lazyCustomAttributesBag); }
public void Positive() { var single = OneOrMany.Create(123); var quad = OneOrMany.Create(ImmutableArray.Create <int>(10, 20, 30, 40)); Assert.Equal(1, single.Count); Assert.Equal(123, single[0]); Assert.Equal(10, quad[0]); Assert.Equal(20, quad[1]); Assert.Equal(30, quad[2]); Assert.Equal(40, quad[3]); }
private CustomAttributesBag <CSharpAttributeData> GetAttributesBag() { if (_lazyCustomAttributesBag == null || !_lazyCustomAttributesBag.IsSealed) { var mergedAttributes = ((SourceAssemblySymbol)this.ContainingAssembly).GetAttributeDeclarations(); if (LoadAndValidateAttributes(OneOrMany.Create(mergedAttributes), ref _lazyCustomAttributesBag)) { var completed = _state.NotePartComplete(CompletionPart.Attributes); Debug.Assert(completed); } } return(_lazyCustomAttributesBag); }
public void Contains() { Assert.True(OneOrMany.Create(1).Contains(1)); Assert.False(OneOrMany.Create(1).Contains(0)); Assert.False(OneOrMany.Create(ImmutableArray <int> .Empty).Contains(0)); Assert.True(OneOrMany.Create(ImmutableArray.Create(1)).Contains(1)); Assert.False(OneOrMany.Create(ImmutableArray.Create(1)).Contains(0)); Assert.True(OneOrMany.Create(ImmutableArray.Create(1, 2)).Contains(1)); Assert.True(OneOrMany.Create(ImmutableArray.Create(1, 2)).Contains(2)); Assert.False(OneOrMany.Create(ImmutableArray.Create(1, 2)).Contains(0)); }
internal override OneOrMany <SyntaxList <AttributeListSyntax> > GetAttributeDeclarations() { if (this.IsPrimaryCtor) { if ((object)((SourceNamedTypeSymbol)ContainingType).PrimaryCtor == (object)this) { // Main Primary Constructor gets its attributes from attributes on the type. return(OneOrMany.Create(((SourceNamedTypeSymbol)ContainingType).GetAttributeDeclarations())); } // Non-Main Primary constructor doesn't have attributes. return(OneOrMany.Create(default(SyntaxList <AttributeListSyntax>))); } return(OneOrMany.Create(((ConstructorDeclarationSyntax)this.SyntaxNode).AttributeLists)); }
/// <summary> /// Returns a bag of applied custom attributes and data decoded from well-known attributes. Returns null if there are no attributes applied on the symbol. /// </summary> /// <remarks> /// Forces binding and decoding of attributes. /// </remarks> private CustomAttributesBag <CSharpAttributeData> GetAttributesBag() { var bag = this.lazyCustomAttributesBag; if (bag != null && bag.IsSealed) { return(bag); } if (LoadAndValidateAttributes(OneOrMany.Create(this.AttributeDeclarationSyntaxList), ref lazyCustomAttributesBag)) { var completed = state.NotePartComplete(CompletionPart.Attributes); Debug.Assert(completed); } Debug.Assert(lazyCustomAttributesBag.IsSealed); return(this.lazyCustomAttributesBag); }
/// <summary> /// Gets the syntax list of custom attributes that declares atributes for this parameter symbol. /// </summary> internal virtual OneOrMany <SyntaxList <AttributeListSyntax> > GetAttributeDeclarations() { // C# spec: // The attributes on the parameters of the resulting method declaration // are the combined attributes of the corresponding parameters of the defining // and the implementing partial method declaration in unspecified order. // Duplicates are not removed. SyntaxList <AttributeListSyntax> attributes = AttributeDeclarationList; var sourceMethod = this.ContainingSymbol as SourceMemberMethodSymbol; if ((object)sourceMethod == null) { return(OneOrMany.Create(attributes)); } SyntaxList <AttributeListSyntax> otherAttributes; // if this is a definition get the implementation and vice versa SourceMemberMethodSymbol otherPart = sourceMethod.OtherPartOfPartial; if ((object)otherPart != null) { otherAttributes = ((SourceParameterSymbol)otherPart.Parameters[this.Ordinal]).AttributeDeclarationList; } else { otherAttributes = default(SyntaxList <AttributeListSyntax>); } if (attributes.Equals(default(SyntaxList <AttributeListSyntax>))) { return(OneOrMany.Create(otherAttributes)); } else if (otherAttributes.Equals(default(SyntaxList <AttributeListSyntax>))) { return(OneOrMany.Create(attributes)); } return(OneOrMany.Create(ImmutableArray.Create(attributes, otherAttributes))); }
internal override OneOrMany <SyntaxList <AttributeListSyntax> > GetAttributeDeclarations() { return(OneOrMany.Create(((ConstructorDeclarationSyntax)this.SyntaxNode).AttributeLists)); }
> GetAttributeDeclarations() { return(OneOrMany.Create(this.GetSyntax().AttributeLists)); }
> GetAttributeDeclarations() => OneOrMany.Create(default(SyntaxList <AttributeListSyntax>));
internal override OneOrMany <SyntaxList <AttributeListSyntax> > GetReturnTypeAttributeDeclarations() { // Constructors don't have return type attributes return(OneOrMany.Create(default(SyntaxList <AttributeListSyntax>))); }
internal override OneOrMany <SyntaxList <AttributeListSyntax> > GetAttributeDeclarations() { return(OneOrMany.Create(this.AssociatedEvent.AttributeDeclarationSyntaxList)); }
internal sealed override OneOrMany <SyntaxList <AttributeListSyntax> > GetAttributeDeclarations() { // TODO: This implementation looks strange. It might make sense for the Invoke method, but // not for constructor and other methods. return(OneOrMany.Create(((SourceNamedTypeSymbol)ContainingSymbol).GetAttributeDeclarations())); }
internal sealed override OneOrMany <SyntaxList <AttributeListSyntax> > GetAttributeDeclarations() => OneOrMany.Create(default(SyntaxList <AttributeListSyntax>));
internal override OneOrMany <SyntaxList <AttributeListSyntax> > GetAttributeDeclarations() { return(OneOrMany.Create(Syntax.AttributeLists)); }
internal override OneOrMany <SyntaxList <AttributeListSyntax> > GetAttributeDeclarations() { // destructors can't have return type attributes return(OneOrMany.Create(((DestructorDeclarationSyntax)this.SyntaxNode).AttributeLists)); }
internal sealed override OneOrMany <SyntaxList <AttributeListSyntax> > GetAttributeDeclarations() { return(OneOrMany.Create(this.GetSyntax().AttributeLists)); }