Add IOperation support for tuple expressions #19636

mavasani · 2017-05-18T22:35:17Z

    public interface ITupleExpression : IOperation
    {
        /// <summary>
        /// Elements for tuple expression.
        /// </summary>
        ImmutableArray<IOperation> Elements { get; }
    }

Fixes #10856 ``` public interface ITupleExpression : IOperation { /// <summary> /// Elements for tuple expression. /// </summary> ImmutableArray<IOperation> Elements { get; } } ```

mavasani · 2017-05-18T22:35:43Z

Tagging @AlekseyTs @cston @dotnet/analyzer-ioperation @dotnet/roslyn-compiler #Closed

mavasani · 2017-05-22T22:49:17Z

Ping... #Closed

heejaechang · 2017-05-22T22:59:07Z

👍 #Resolved

cston · 2017-05-23T15:06:58Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ITupleExpression.cs

+        }
+
+        [Fact, WorkItem(10856, "https://github.com/dotnet/roslyn/issues/10856")]
+        public void TupleExpression_NamedArguments()


NamedElements?

Yes, can rename the test.

jcouv · 2017-05-23T16:36:13Z

src/Compilers/Core/Portable/PublicAPI.Unshipped.txt

@@ -828,6 +832,7 @@ virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitSwitchStatement(M
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitSyntheticLocalReferenceExpression(Microsoft.CodeAnalysis.Semantics.ISyntheticLocalReferenceExpression operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitThrowStatement(Microsoft.CodeAnalysis.Semantics.IThrowStatement operation) -> void
 virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitTryStatement(Microsoft.CodeAnalysis.Semantics.ITryStatement operation) -> void
+virtual Microsoft.CodeAnalysis.Semantics.OperationVisitor.VisitTupleExpression(Microsoft.CodeAnalysis.Semantics.ITupleExpression operation) -> void


FYI @jaredpar @gafter for public API change.

jcouv · 2017-05-23T16:39:10Z

src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs

@@ -3837,6 +3837,63 @@ public LazyTryStatement(Lazy<IBlockStatement> body, Lazy<ImmutableArray<ICatchCl
    }

    /// <summary>


Out of curiosity, how is this file generated? What are the inputs used and the command to run? #Resolved

This is currently a hand crafted file, but @heejaechang is working on a generator (similar to our bound node and syntax node generator based on an xml). @jinujoseph - I think we need to check that in soon to avoid extra manual work in coding and reviews and also prevent unintentional coding errors in the generated file. Do we plan to enable this soon? #Resolved

jcouv · 2017-05-23T16:42:11Z

src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs

+
+        private static ITupleExpression CreateBoundTupleExpressionOperation(BoundTupleExpression boundTupleExpression)
+        {
+            Lazy<ImmutableArray<IOperation>> elements = new Lazy<ImmutableArray<IOperation>>(() => GetTupleElements(boundTupleExpression));


Nit: you could omit the type (use var) since type is spelled out on the right-hand-side. #Resolved

I have followed the existing pattern used in this file @heejaechang probably we can clean this up for the entire file in one of your refactorings?

Use of var is not a requirement. It is the other way around, we forbid use of var in some cases.

jcouv · 2017-05-23T16:43:50Z

src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs

+
+        private static ITupleExpression CreateBoundTupleExpressionOperation(BoundTupleExpression boundTupleExpression)
+        {
+            Lazy<ImmutableArray<IOperation>> elements = new Lazy<ImmutableArray<IOperation>>(() => GetTupleElements(boundTupleExpression));


This lambda (and all others above) are creating closures. The compiler generally tries to avoid this, so I'm surprised to see this a recurring pattern in this file. Maybe something to consider for a follow-up refactoring as well?

Yes, certainly. Let me file an issue to track all your review comments here.. Thanks!

Filed #19720

jcouv · 2017-05-23T16:45:18Z

src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs

+    {
+        private readonly Lazy<ImmutableArray<IOperation>> _lazyElements;
+
+        public LazyTupleExpression(Lazy<ImmutableArray<IOperation>> elements, bool isInvalid, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue) :


Note that the type may be null. Consider naming this field typeOpt if that is allowed by the generation tool.

jcouv · 2017-05-23T16:47:06Z

src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs

+            bool isInvalid = boundTupleExpression.HasErrors;
+            SyntaxNode syntax = boundTupleExpression.Syntax;
+            ITypeSymbol type = boundTupleExpression.Type;
+            Optional<object> constantValue = ConvertToOptional(boundTupleExpression.ConstantValue);


I don't think tuple can ever have a constant value. #WontFix

I don't think tuple can ever have a constant value.

The bound node will reflect that.

I would keep this as is. If tuples could ever become constnat, then this code will continue to work.

jcouv · 2017-05-23T16:50:26Z

src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory_Methods.cs

@@ -340,6 +340,15 @@ private static ImmutableArray<IVariableDeclaration> GetVariableDeclarationStatem
                        OperationFactory.CreateVariableDeclaration(declaration.LocalSymbol, Create(declaration.InitializerOpt), declaration.Syntax)));
        }

+        private static readonly ConditionalWeakTable<BoundTupleExpression, object> s_tupleElementsMappings =


Is there a reason not to have specific type (as opposed to object) for the values stored in the table?

@heejaechang? Comment tracked in #19720

The problem with CWT is that it has a 'class' constraint on the values. But we're storing ImmutableArrays. So we end up needing to box things into object to satisfy the CWT.

jcouv · 2017-05-23T16:52:08Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_IParameterReferenceExpression.cs

-IOperation:  (OperationKind.None) (Syntax: '(x, x + y)')
-  Children(2): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')
+ITupleExpression (OperationKind.TupleExpression, Type: (System.Int32 x, System.Int32)) (Syntax: '(x, x + y)')
+  Elements(2): IParameterReferenceExpression: x (OperationKind.ParameterReferenceExpression, Type: System.Int32) (Syntax: 'x')


In terms of formatting, maybe IParameterReferenceExpression: x ... should be on the next line, indented with IBinaryOperatorExpression ...? #Pending

Yes, we hope to make that change in the dump format, but it would require updating almost all the IOperation tests. We have it in our backlog though...

Filed #19866

In reply to: 118046117 [](ancestors = 118046117)

jcouv · 2017-05-23T16:55:32Z

src/Compilers/Core/Portable/Operations/ITupleExpression.cs

+        /// <summary>
+        /// Elements for tuple expression.
+        /// </summary>
+        ImmutableArray<IOperation> Elements { get; }


This is a general comment beyond this PR, but I'm concerned about materializing more data structures to represent existing information. I would have expected IOperation to be much more "view-like".

jcouv · 2017-05-23T16:58:31Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ITupleExpression.cs

+}
+";
+            string expectedOperationTree = @"
+IOperation:  (OperationKind.None) (Syntax: '(uint x, ui ... Point(0, 1)')


Also beyond the scope of this PR, but we have some test infrastructure to dump tree information (TreeDumperNode). Maybe it would be useful for IOperation tests, rather than inventing a new format?

AlekseyTs · 2017-05-23T22:27:31Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ITupleExpression.cs

+}
+";
+            string expectedOperationTree = @"
+ITupleExpression (OperationKind.TupleExpression, Type: (System.UInt32, System.UInt32)) (Syntax: '(1, 2)')


It would be good to check what conversion node we have on top of this node, if any.

AlekseyTs · 2017-05-23T22:27:42Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ITupleExpression.cs

+}
+";
+            string expectedOperationTree = @"
+ITupleExpression (OperationKind.TupleExpression, Type: (System.Int32, System.Int32)) (Syntax: '(1, 2)')


It would be good to check what conversion node we have on top of this node, if any. #Resolved

AlekseyTs · 2017-05-23T22:27:56Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ITupleExpression.cs

+}
+";
+            string expectedOperationTree = @"
+ITupleExpression (OperationKind.TupleExpression, Type: (System.UInt32, System.String)) (Syntax: '(1, null)')


It would be good to check what conversion node we have on top of this node, if any.

AlekseyTs · 2017-05-23T22:28:53Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ITupleExpression.cs

+}
+";
+            string expectedOperationTree = @"
+ITupleExpression (OperationKind.TupleExpression, Type: (System.Int32, System.Int32)) (Syntax: '(1, 2)')


It would be good to check what conversion node we have on top of this node, if any.

AlekseyTs · 2017-05-23T22:29:17Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ITupleExpression.cs

+}
+";
+            string expectedOperationTree = @"
+ITupleExpression (OperationKind.TupleExpression, Type: (System.Int16 A, System.String B)) (Syntax: '(A: 1, B: null)')


It would be good to check what conversion node we have on top of this node, if any.

AlekseyTs · 2017-05-23T22:32:52Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ITupleExpression.cs

+  IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration) (Syntax: 'C t /*<bind ... *</bind>*/;')
+    Variables: Local_1: C t
+    Initializer: IConversionExpression (ConversionKind.OperatorMethod, Implicit) (OperatorMethod: C C.op_Implicit((System.Int32, System.String) x)) (OperationKind.ConversionExpression, Type: C) (Syntax: '(0, null)')
+        IConversionExpression (ConversionKind.CSharp, Implicit) (OperationKind.ConversionExpression, Type: (System.Int32, System.String)) (Syntax: '(0, null)')


IConversionExpression (ConversionKind.CSharp, Implicit) (OperationKind.ConversionExpression, Type: (System.Int32, System.String)) (Syntax: '(0, null)') [](start = 8, length = 151)

This conversion feels unexpected, it looks like there is no type change from the operand.

@AlekseyTs Is this a compiler issue? I will file a bug regardless...

Is this a compiler issue?

We should not expect that the shape of the bound tree is what we want IOperation tree to have. It is possible that this particular problem can be addressed by adjusting the shape of the bound tree, it has to be investigated. I would treet this an IOperation issue as long as compiler behaves as expected (the shape of the bound tree is not part of the behavior) and other public APIs behave as expected too.

AlekseyTs · 2017-05-23T22:36:27Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ITupleExpression.cs

+";
+            string expectedOperationTree = @"
+IOperation:  (OperationKind.None) (Syntax: 'var (x, y)  ... Point(0, 1)')
+  Children(2): ITupleExpression (OperationKind.TupleExpression, Type: (System.Int32 x, System.Int32 y)) (Syntax: 'var (x, y)')


Children(2): ITupleExpression (OperationKind.TupleExpression, Type: (System.Int32 x, System.Int32 y)) (Syntax: 'var (x, y)') [](start = 2, length = 124)

This doesn't look right, var (x, y) is not a tuple expression.

This is not surprising to me. var (x, y) is the short-hand for (var x, var y) and so is bound the same way.
What should we get here instead?

In reply to: 118122825 [](ancestors = 118122825)

What should we get here instead?

The question is not how we represent things internally, but how IOperation should represent this. Syntactically this is not a tuple expression, perhaps it should be represented by a special IOperation node, a declaration expression, etc. Something for the design team to decide.

AlekseyTs · 2017-05-23T22:37:41Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ITupleExpression.cs

+";
+            string expectedOperationTree = @"
+IOperation:  (OperationKind.None) (Syntax: '(uint x, ui ... Point(0, 1)')
+  Children(2): ITupleExpression (OperationKind.TupleExpression, Type: (System.UInt32 x, System.UInt32 y)) (Syntax: '(uint x, uint y)')


Children(2): ITupleExpression (OperationKind.TupleExpression, Type: (System.UInt32 x, System.UInt32 y)) (Syntax: '(uint x, uint y)') [](start = 2, length = 132)

This doesn't look right, (uint x, uint y) is not a tuple expression.

I think it is a tuple expression, containing two declaration expressions.

I think it is a tuple expression, containing two declaration expressions.

I see, that makes sense now. The elements of the tuple should probably reflect that.

Yes. Each element should be a bound local with a flag set marking it as a declaration. new BoundLocal(..., isDeclaration: true, ...).
Maybe we should expose that flag, to distinguish plain locals and declaration expressions?

In reply to: 118129477 [](ancestors = 118129477)

AlekseyTs · 2017-05-23T22:40:11Z

src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationFactory.vb

@@ -161,6 +161,8 @@ Namespace Microsoft.CodeAnalysis.Semantics
                    Return CreateBoundAddHandlerStatementOperation(DirectCast(boundNode, BoundAddHandlerStatement))
                Case BoundKind.RemoveHandlerStatement
                    Return CreateBoundRemoveHandlerStatementOperation(DirectCast(boundNode, BoundRemoveHandlerStatement))
+                Case BoundKind.TupleLiteral, BoundKind.ConvertedTupleLiteral


BoundKind.ConvertedTupleLiteral [](start = 45, length = 31)

Please put this value on the next line for readability.

AlekseyTs · 2017-05-23T22:46:05Z

src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ITupleExpression.vb

+End Class]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: (System.UInt32, System.UInt32)) (Syntax: '(1, 2)')


It looks like similar test in C# does not include this conversion. The conversion feels unexpected, there is no type change from the operand.

AlekseyTs · 2017-05-23T22:46:52Z

src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ITupleExpression.vb

+
+Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests.Semantics
+
+    Partial Public Class IOperationTests


IOperationTests [](start = 25, length = 15)

Many comments for C# tests are applicable for VB tests as well.

AlekseyTs · 2017-05-23T22:47:08Z

src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ITupleExpression.vb

+End Class]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: (System.UInt32, System.String)) (Syntax: '(1, Nothing)')


Same comment.

AlekseyTs · 2017-05-23T22:49:42Z

src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ITupleExpression.vb

+End Class]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: (A As System.Int32, B As System.Int32)) (Syntax: '(1, 2)')


The conversion feels unexpected, given the syntax we examine.

AlekseyTs · 2017-05-23T22:51:17Z

src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ITupleExpression.vb

+End Class]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: (A As System.Int16, B As System.String)) (Syntax: '(A:=1, B:=Nothing)')


The conversion feels unexpected given the syntax we examine. Also, there is no type change from the operand.

AlekseyTs · 2017-05-23T22:54:25Z

src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ITupleExpression.vb

+End Class]]>.Value
+
+            Dim expectedOperationTree = <![CDATA[
+IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: (A As System.Int16, B As System.String)) (Syntax: '(New C(0), c1)')


This conversion feels strange too.

AlekseyTs · 2017-05-23T22:57:19Z

src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ITupleExpression.vb

+
+            Dim expectedOperationTree = <![CDATA[
+IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: C) (Syntax: '(0, Nothing)')
+  IConversionExpression (ConversionKind.OperatorMethod, Implicit) (OperatorMethod: Function C.op_Implicit(x As (System.Int32, System.String)) As C) (OperationKind.ConversionExpression, Type: (System.Int32, System.Object)) (Syntax: '(0, Nothing)')


Type: (System.Int32, System.Object) [](start = 185, length = 35)

I am confused, why the type is a tuple when the operator returns C?

AlekseyTs · 2017-05-23T22:58:09Z

src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ITupleExpression.vb

+IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: C) (Syntax: '(0, Nothing)')
+  IConversionExpression (ConversionKind.OperatorMethod, Implicit) (OperatorMethod: Function C.op_Implicit(x As (System.Int32, System.String)) As C) (OperationKind.ConversionExpression, Type: (System.Int32, System.Object)) (Syntax: '(0, Nothing)')
+    IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: (System.Int32, System.Object)) (Syntax: '(0, Nothing)')
+      ITupleExpression (OperationKind.TupleExpression, Type: (System.Int32, System.Object)) (Syntax: '(0, Nothing)')


ITupleExpression (OperationKind.TupleExpression, Type: (System.Int32, System.Object)) (Syntax: '(0, Nothing)') [](start = 6, length = 110)

Everything above tuple literal looks strange.

AlekseyTs · 2017-05-23T22:59:25Z

src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ITupleExpression.vb

+    End Operator
+
+    Public Sub M(c1 As C)
+        Dim t As (Integer, String) = c1'BIND:"Dim t As (Integer, String) = c1"


'BIND:"Dim t As (Integer, String) = c1" [](start = 39, length = 39)

It would also be interesting testing what we return just for c1

AlekseyTs · 2017-05-23T23:00:15Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ITupleExpression.cs

+
+    public void M(C c1)
+    {
+        (int, string) t /*<bind>*/= c1/*</bind>*/;


c1 [](start = 36, length = 2)

What do we get when we bind just c1?

AlekseyTs · 2017-05-23T23:01:51Z

src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ITupleExpression.vb

+    Variables: Local_1: t As (System.Int32, System.String)
+    Initializer: IConversionExpression (ConversionKind.Basic, Implicit) (OperationKind.ConversionExpression, Type: (System.Int32, System.String)) (Syntax: 'c1')
+        IConversionExpression (ConversionKind.OperatorMethod, Implicit) (OperatorMethod: Function C.op_Implicit(c As C) As (System.Int32, System.String)) (OperationKind.ConversionExpression, Type: C) (Syntax: 'c1')
+          IParameterReferenceExpression: c1 (OperationKind.ParameterReferenceExpression, Type: C) (Syntax: 'c1')


IParameterReferenceExpression: c1 (OperationKind.ParameterReferenceExpression, Type: C) (Syntax: 'c1') [](start = 10, length = 102)

The two conversions above look strange.

AlekseyTs · 2017-05-23T23:03:29Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ITupleExpression.cs

+
+    public void M(C c1)
+    {
+        /*<bind>*/(short, string) t = (new C(0), c1);/*</bind>*/


(new C(0), c1) [](start = 38, length = 14)

What is the result when we bind just the tuple?

AlekseyTs · 2017-05-23T23:08:40Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ITupleExpression.cs

+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests
+{
+    public partial class IOperationTests : SemanticModelTestBase


IOperationTests [](start = 25, length = 15)

Do we have a test that uses user-defined conversion on a tuple literal, which requires conversions for tuple elements, including user-defined ones?

AlekseyTs · 2017-05-23T23:09:58Z

src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ITupleExpression.vb

+    End Operator
+
+    Public Sub M(c1 As C)
+        Dim t As (Short, String) = (New C(0), c1)'BIND:"Dim t As (Short, String) = (New C(0), c1)"


(New C(0), c1) [](start = 83, length = 14)

What happens if we bind just the tuple?

AlekseyTs · 2017-05-23T23:13:13Z

src/Compilers/VisualBasic/Test/Semantic/IOperation/IOperationTests_ITupleExpression.vb

+IVariableDeclarationStatement (1 declarations) (OperationKind.VariableDeclarationStatement, IsInvalid) (Syntax: 'Dim t As (S ... w C(0), c1)')
+  IVariableDeclaration (1 variables) (OperationKind.VariableDeclaration, IsInvalid) (Syntax: 't')
+    Variables: Local_1: t As (System.Int16, System.String)
+    Initializer: ITupleExpression (OperationKind.TupleExpression, Type: (System.Int16, c1 As System.String), IsInvalid) (Syntax: '(New C(0), c1)')


ITupleExpression (OperationKind.TupleExpression, Type: (System.Int16, c1 As System.String), IsInvalid) (Syntax: '(New C(0), c1)') [](start = 17, length = 129)

Given other tests, it is not clear if we want to have a conversion on top of this node.

AlekseyTs · 2017-05-23T23:14:17Z

Done with review pass. I think we need to have a discussion about how tuple literal conversions should be represented.

jcouv · 2017-05-24T15:10:39Z

src/Compilers/CSharp/Test/Semantic/IOperation/IOperationTests_ITupleExpression.cs

+  Children(2): ITupleExpression (OperationKind.TupleExpression, Type: (System.UInt32 x, System.UInt32 y)) (Syntax: '(uint x, uint y)')
+      Elements(2): ILocalReferenceExpression: x (OperationKind.LocalReferenceExpression, Type: System.UInt32) (Syntax: 'uint x')
+        ILocalReferenceExpression: y (OperationKind.LocalReferenceExpression, Type: System.UInt32) (Syntax: 'uint y')
+    IConversionExpression (ConversionKind.Invalid, Implicit) (OperationKind.ConversionExpression, Type: (System.UInt32 x, System.UInt32 y)) (Syntax: 'new Point(0, 1)')


I'm a surprised by ConversionKind.Invalid here.
In the bound tree, I expect a deconstruction conversion. That conversion is "secret" (implementation-only, will likely not be in the spec). I'm not sure how it should be surfaced, but "invalid" seems wrong.

I'm a surprised by ConversionKind.Invalid here.

We are still figuring out how deconstruction should be represented. At the moment, we just show what the bound node has. Since conversion kind is not one of the conversions supported by the language, it is surfaced as invalid, I guess.

mavasani · 2017-05-30T17:29:56Z

Thanks for the reviews! I have added some additional comments to #10856 (comment) so we can discuss this at the next IOperation design meeting.

mavasani · 2017-07-10T17:30:02Z

Closing in favor of #20749

Add IOperation support for tuple expressions

50fee94

Fixes #10856 ``` public interface ITupleExpression : IOperation { /// <summary> /// Elements for tuple expression. /// </summary> ImmutableArray<IOperation> Elements { get; } } ```

dnfclas added the cla-already-signed label May 18, 2017

mavasani added Area-Analyzers Area-Compilers labels May 18, 2017

cston reviewed May 23, 2017

View reviewed changes

jcouv reviewed May 23, 2017

View reviewed changes

mavasani mentioned this pull request May 23, 2017

OperationFactory/Operations.Generated.cs refactoring #19720

Closed

jcouv reviewed May 23, 2017

View reviewed changes

AlekseyTs reviewed May 23, 2017

View reviewed changes

CyrusNajmabadi approved these changes May 23, 2017

View reviewed changes

AlekseyTs reviewed May 23, 2017

View reviewed changes

jcouv reviewed May 24, 2017

View reviewed changes

mavasani mentioned this pull request May 30, 2017

Implement IOperation support for tuple literals #10856

Closed

heejaechang mentioned this pull request Jun 27, 2017

Create Generator similar to bound node generator that creates basic IOperation types #20204

Closed

mavasani closed this Jul 10, 2017

This was referenced Jul 10, 2017

Do not expose redundant implicit identity conversion on top of tuple expressions and foreach collection #20756

Open

Add IOperation support for tuple expressions #20749

Merged

khyperia deleted the Tuples branch September 25, 2017 22:48

		@@ -3837,6 +3837,63 @@ public LazyTryStatement(Lazy<IBlockStatement> body, Lazy<ImmutableArray<ICatchCl
		}

		/// <summary>


		Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests.Semantics

		Partial Public Class IOperationTests

Add IOperation support for tuple expressions #19636

Add IOperation support for tuple expressions #19636

Conversation

mavasani commented May 18, 2017

mavasani commented May 18, 2017 • edited Loading

mavasani commented May 22, 2017 • edited Loading

heejaechang commented May 22, 2017 • edited by mavasani Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jcouv May 23, 2017 • edited by mavasani Loading

Choose a reason for hiding this comment

mavasani May 23, 2017 • edited Loading

Choose a reason for hiding this comment

jcouv May 23, 2017 • edited by mavasani Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jcouv May 23, 2017 • edited by mavasani Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jcouv May 23, 2017 • edited by mavasani Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs May 23, 2017 • edited by jcouv Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs commented May 23, 2017

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mavasani commented May 30, 2017

mavasani commented Jul 10, 2017

mavasani commented May 18, 2017 •

edited

Loading

mavasani commented May 22, 2017 •

edited

Loading

heejaechang commented May 22, 2017 •

edited by mavasani

Loading

jcouv May 23, 2017 •

edited by mavasani

Loading

mavasani May 23, 2017 •

edited

Loading

jcouv May 23, 2017 •

edited by mavasani

Loading

jcouv May 23, 2017 •

edited by mavasani

Loading

jcouv May 23, 2017 •

edited by mavasani

Loading

AlekseyTs May 23, 2017 •

edited by jcouv

Loading