added semantic model to all operation

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs

@@ -525,10 +525,11 @@ private static bool IsSafeForReordering(BoundExpression expression, RefKind kind
                 ImmutableArray<ParameterSymbol> parameters = methodOrIndexer.GetParameters();
                 ArrayBuilder<IArgument> argumentsBuilder = ArrayBuilder<IArgument>.GetInstance(arguments.Length);
 
+
                 int i = 0;
                 for (; i < parameters.Length; ++i)
                 {
-                    argumentsBuilder.Add(CSharpOperationFactory.CreateArgumentOperation(ArgumentKind.Explicit, parameters[i], operationFactory.Create(arguments[i])));
+                    argumentsBuilder.Add(operationFactory.CreateArgumentOperation(ArgumentKind.Explicit, parameters[i], arguments[i]));
                 }
 
                 // TODO: In case of __arglist, we will have more arguments than parameters, 
@@ -536,13 +537,13 @@ private static bool IsSafeForReordering(BoundExpression expression, RefKind kind
                 //       https://github.com/dotnet/roslyn/issues/19673
                 for (; i < arguments.Length; ++i)
                 {
-                    argumentsBuilder.Add(CSharpOperationFactory.CreateArgumentOperation(ArgumentKind.Explicit, null, operationFactory.Create(arguments[i])));
+                    argumentsBuilder.Add(operationFactory.CreateArgumentOperation(ArgumentKind.Explicit, null, arguments[i]));
                 }
 
                 Debug.Assert(methodOrIndexer.GetIsVararg() ^ parameters.Length == arguments.Length);
 
                 return argumentsBuilder.ToImmutableAndFree();
-            }                                                                                                                   
+            }
 
             return BuildArgumentsInEvaluationOrder(
                 operationFactory,
@@ -713,7 +714,7 @@ private static ImmutableArray<RefKind> GetRefKindsOrNull(ArrayBuilder<RefKind> r
                     argument = CreateParamArrayArgument(syntax, parameter.Type, paramArray.ToImmutableAndFree(), null, binder);
                 }
 
-                argumentsInEvaluationBuilder.Add(CSharpOperationFactory.CreateArgumentOperation(kind, parameter, operationFactory.Create(argument)));
+                argumentsInEvaluationBuilder.Add(operationFactory.CreateArgumentOperation(kind, parameter, argument));
             }
 
             // Collect parameters with missing arguments.   
@@ -1065,7 +1066,7 @@ private static BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue cons
                     unusedDiagnostics.Free();
                 }
 
-                argumentsBuilder.Add(CSharpOperationFactory.CreateArgumentOperation(kind, parameter, operationFactory.Create(argument)));
+                argumentsBuilder.Add(operationFactory.CreateArgumentOperation(kind, parameter, argument));
             }
         }
 

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

@@ -32,13 +32,16 @@ private ImmutableArray<IOperation> ToStatements(BoundStatement statement)
             return ImmutableArray.Create(Create(statement));
         }
 
-        internal static IArgument CreateArgumentOperation(ArgumentKind kind, IParameterSymbol parameter, IOperation value)
+        internal IArgument CreateArgumentOperation(ArgumentKind kind, IParameterSymbol parameter, BoundExpression expression)
         {
+            var value = Create(expression);
+
             return new Argument(kind,
                 parameter,
                 value,
                 inConversion: null,
                 outConversion: null,
+                semanticModel: _semanticModel,
                 syntax: value.Syntax,
                 type: value.Type,
                 constantValue: default);
@@ -72,14 +75,14 @@ internal static IArgument CreateArgumentOperation(ArgumentKind kind, IParameterS
             //      invocation instead.
             //      Note this check doesn't cover all scenarios. For example, when a parameter is a generic type but the type of the type argument 
             //      is undefined.
-            if ((object)optionalParametersMethod == null 
+            if ((object)optionalParametersMethod == null
                 || boundNode.HasAnyErrors
                 || parameters.Any(p => p.Type.IsErrorType())
                 || optionalParametersMethod.GetUseSiteDiagnostic()?.DefaultSeverity == DiagnosticSeverity.Error)
             {
                 // optionalParametersMethod can be null if we are writing to a readonly indexer or reading from an writeonly indexer,
                 // in which case HasErrors property would be true, but we still want to treat this as invalid invocation.
-                return boundArguments.SelectAsArray(arg => CreateArgumentOperation(ArgumentKind.Explicit, null, Create(arg)));
+                return boundArguments.SelectAsArray(arg => CreateArgumentOperation(ArgumentKind.Explicit, null, arg));
             }
 
             return LocalRewriter.MakeArgumentsInEvaluationOrder(
@@ -113,7 +116,7 @@ private ImmutableArray<IOperation> GetAnonymousObjectCreationInitializers(BoundA
                 SyntaxNode syntax = value.Syntax?.Parent ?? expression.Syntax;
                 ITypeSymbol type = target.Type;
                 Optional<object> constantValue = value.ConstantValue;
-                var assignment = new SimpleAssignmentExpression(target, value, syntax, type, constantValue);
+                var assignment = new SimpleAssignmentExpression(target, value, _semanticModel, syntax, type, constantValue);
                 builder.Add(assignment);
             }
 
@@ -185,7 +188,7 @@ private ImmutableArray<ISwitchCase> GetSwitchStatementCases(BoundSwitchStatement
                 var clauses = switchSection.SwitchLabels.SelectAsArray(s => (ICaseClause)Create(s));
                 var body = switchSection.Statements.SelectAsArray(s => Create(s));
 
-                return (ISwitchCase)new SwitchCase(clauses, body, switchSection.Syntax, type: null, constantValue: default(Optional<object>));
+                return (ISwitchCase)new SwitchCase(clauses, body, _semanticModel, switchSection.Syntax, type: null, constantValue: default(Optional<object>));
             });
         }
 
@@ -196,7 +199,7 @@ private ImmutableArray<ISwitchCase> GetPatternSwitchStatementCases(BoundPatternS
                 var clauses = switchSection.SwitchLabels.SelectAsArray(s => (ICaseClause)Create(s));
                 var body = switchSection.Statements.SelectAsArray(s => Create(s));
 
-                return (ISwitchCase)new SwitchCase(clauses, body, switchSection.Syntax, type: null, constantValue: default(Optional<object>));
+                return (ISwitchCase)new SwitchCase(clauses, body, _semanticModel, switchSection.Syntax, type: null, constantValue: default(Optional<object>));
             });
         }
 

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

@@ -20,7 +20,7 @@ internal abstract class Operation : IOperation
         // but once initialized, will never change
         private IOperation _parentDoNotAccessDirectly;
 
-        public Operation(SemanticModel semanticModel, OperationKind kind, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue)
+        public Operation(OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional<object> constantValue)
         {
             _semanticModel = semanticModel;
 
@@ -99,7 +99,7 @@ private class NoneOperation : Operation
             private readonly Func<ImmutableArray<IOperation>> _getChildren;
 
             public NoneOperation(SemanticModel semanticMode, SyntaxNode node, Optional<object> constantValue, Func<ImmutableArray<IOperation>> getChildren) :
-                base(semanticMode, OperationKind.None, node, type: null, constantValue: constantValue)
+                base(OperationKind.None, semanticMode, node, type: null, constantValue: constantValue)
             {
                 _getChildren = getChildren;
             }

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

@@ -7,40 +7,42 @@ namespace Microsoft.CodeAnalysis.Semantics
 {
     internal static class OperationFactory
     {
-        public static IVariableDeclaration CreateVariableDeclaration(ILocalSymbol variable, IOperation initialValue, SyntaxNode syntax)
+        public static IVariableDeclaration CreateVariableDeclaration(ILocalSymbol variable, IOperation initialValue, SemanticModel semanticModel, SyntaxNode syntax)
         {
-            return CreateVariableDeclaration(ImmutableArray.Create(variable), initialValue, syntax);
+            return CreateVariableDeclaration(ImmutableArray.Create(variable), initialValue, semanticModel, syntax);
         }
 
-        public static VariableDeclaration CreateVariableDeclaration(ImmutableArray<ILocalSymbol> variables, IOperation initialValue, SyntaxNode syntax)
+        public static VariableDeclaration CreateVariableDeclaration(ImmutableArray<ILocalSymbol> variables, IOperation initialValue, SemanticModel semanticModel, SyntaxNode syntax)
         {
             return new VariableDeclaration(
                 variables,
                 initialValue,
+                semanticModel,
                 syntax,
                 type: null,
                 constantValue: default(Optional<object>));
         }
 
-        public static IConditionalChoiceExpression CreateConditionalChoiceExpression(IOperation condition, IOperation ifTrue, IOperation ifFalse, ITypeSymbol resultType, SyntaxNode syntax)
+        public static IConditionalChoiceExpression CreateConditionalChoiceExpression(IOperation condition, IOperation ifTrue, IOperation ifFalse, ITypeSymbol resultType, SemanticModel semanticModel, SyntaxNode syntax)
         {
             return new ConditionalChoiceExpression(
                 condition,
                 ifTrue,
                 ifFalse,
+                semanticModel,
                 syntax,
                 resultType,
                 default(Optional<object>));
         }
 
-        public static IExpressionStatement CreateSimpleAssignmentExpressionStatement(IOperation target, IOperation value, SyntaxNode syntax)
+        public static IExpressionStatement CreateSimpleAssignmentExpressionStatement(IOperation target, IOperation value, SemanticModel semanticModel, SyntaxNode syntax)
         {
-            var expression = new SimpleAssignmentExpression(target, value, syntax, target.Type, default(Optional<object>));
-            return new ExpressionStatement(expression, syntax, type: null, constantValue: default(Optional<object>));
+            var expression = new SimpleAssignmentExpression(target, value, semanticModel, syntax, target.Type, default(Optional<object>));
+            return new ExpressionStatement(expression, semanticModel, syntax, type: null, constantValue: default(Optional<object>));
         }
 
         public static IExpressionStatement CreateCompoundAssignmentExpressionStatement(
-            IOperation target, IOperation value, BinaryOperationKind binaryOperationKind, IMethodSymbol operatorMethod, SyntaxNode syntax)
+            IOperation target, IOperation value, BinaryOperationKind binaryOperationKind, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax)
         {
             var expression = new CompoundAssignmentExpression(
                      binaryOperationKind,
@@ -48,53 +50,55 @@ public static IExpressionStatement CreateSimpleAssignmentExpressionStatement(IOp
                      value,
                      operatorMethod != null,
                      operatorMethod,
+                     semanticModel,
                      syntax,
                      target.Type,
                      default(Optional<object>));
 
-            return new ExpressionStatement(expression, syntax, type: null, constantValue: default(Optional<object>));
+            return new ExpressionStatement(expression, semanticModel, syntax, type: null, constantValue: default(Optional<object>));
         }
 
-        public static ILiteralExpression CreateLiteralExpression(long value, ITypeSymbol resultType, SyntaxNode syntax)
+        public static ILiteralExpression CreateLiteralExpression(long value, ITypeSymbol resultType, SemanticModel semanticModel, SyntaxNode syntax)
         {
-            return new LiteralExpression(value.ToString(), syntax: syntax, type: resultType, constantValue: new Optional<object>(value));
+            return new LiteralExpression(value.ToString(), semanticModel, syntax, resultType, constantValue: new Optional<object>(value));
         }
 
-        public static ILiteralExpression CreateLiteralExpression(ConstantValue value, ITypeSymbol resultType, SyntaxNode syntax)
+        public static ILiteralExpression CreateLiteralExpression(ConstantValue value, ITypeSymbol resultType, SemanticModel semanticModel, SyntaxNode syntax)
         {
-            return new LiteralExpression(value.GetValueToDisplay(), syntax, resultType, new Optional<object>(value.Value));
+            return new LiteralExpression(value.GetValueToDisplay(), semanticModel, syntax, resultType, new Optional<object>(value.Value));
         }
 
         public static IBinaryOperatorExpression CreateBinaryOperatorExpression(
-            BinaryOperationKind binaryOperationKind, IOperation left, IOperation right, ITypeSymbol resultType, SyntaxNode syntax)
+            BinaryOperationKind binaryOperationKind, IOperation left, IOperation right, ITypeSymbol resultType, SemanticModel semanticModel, SyntaxNode syntax)
         {
             return new BinaryOperatorExpression(
                 binaryOperationKind, left, right,
                 usesOperatorMethod: false, operatorMethod: null,
-                syntax: syntax, type: resultType, constantValue: default(Optional<object>));
+                semanticModel: semanticModel, syntax: syntax, type: resultType, constantValue: default(Optional<object>));
         }
 
         public static IArrayCreationExpression CreateArrayCreationExpression(
-            IArrayTypeSymbol arrayType, ImmutableArray<IOperation> elementValues, SyntaxNode syntax)
+            IArrayTypeSymbol arrayType, ImmutableArray<IOperation> elementValues, SemanticModel semanticModel, SyntaxNode syntax)
         {
-            var initializer = new ArrayInitializer(elementValues, syntax, arrayType, default(Optional<object>));
+            var initializer = new ArrayInitializer(elementValues, semanticModel, syntax, arrayType, default(Optional<object>));
             return new ArrayCreationExpression(
                 arrayType.ElementType,
-                ImmutableArray.Create<IOperation>(CreateLiteralExpression(elementValues.Count(), resultType: null, syntax: syntax)),
+                ImmutableArray.Create<IOperation>(CreateLiteralExpression(elementValues.Count(), resultType: null, semanticModel: semanticModel, syntax: syntax)),
                 initializer,
+                semanticModel,
                 syntax,
                 arrayType,
                 default(Optional<object>));
         }
 
-        public static IInvalidExpression CreateInvalidExpression(SyntaxNode syntax)
+        public static IInvalidExpression CreateInvalidExpression(SemanticModel semanticModel, SyntaxNode syntax)
         {
-            return CreateInvalidExpression(syntax, ImmutableArray<IOperation>.Empty);
+            return CreateInvalidExpression(semanticModel, syntax, ImmutableArray<IOperation>.Empty);
         }
 
-        public static IInvalidExpression CreateInvalidExpression(SyntaxNode syntax, ImmutableArray<IOperation> children)
+        public static IInvalidExpression CreateInvalidExpression(SemanticModel semanticModel, SyntaxNode syntax, ImmutableArray<IOperation> children)
         {
-            return new InvalidExpression(children: children, syntax: syntax, type: null, constantValue: default(Optional<object>));
+            return new InvalidExpression(children, semanticModel, syntax, type: null, constantValue: default(Optional<object>));
         }
     }
-}
\ No newline at end of file
+}

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

@@ -44,6 +44,7 @@ Microsoft.CodeAnalysis.IOperation.ConstantValue.get -> Microsoft.CodeAnalysis.Op
 Microsoft.CodeAnalysis.IOperation.Kind.get -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.IOperation.Syntax.get -> Microsoft.CodeAnalysis.SyntaxNode
 Microsoft.CodeAnalysis.IOperation.Type.get -> Microsoft.CodeAnalysis.ITypeSymbol
+Microsoft.CodeAnalysis.IOperation.Parent.get -> Microsoft.CodeAnalysis.IOperation
 Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.AddressOfExpression = 515 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.OperationKind.AnonymousObjectCreationExpression = 287 -> Microsoft.CodeAnalysis.OperationKind

src/Compilers/VisualBasic/Portable/Binding/MemberSemanticModel.vb

@@ -37,7 +37,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             _parentSemanticModelOpt = parentSemanticModelOpt
             _speculatedPosition = speculatedPosition
 
-            _operationFactory = New VisualBasicOperationFactory()
+            _operationFactory = New VisualBasicOperationFactory(Me)
         End Sub
 
         Friend ReadOnly Property RootBinder As Binder

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

@@ -41,7 +41,7 @@ Namespace Microsoft.CodeAnalysis.Semantics
                 Return child
             End If
 
-            Return OperationFactory.CreateInvalidExpression([operator].UnderlyingExpression.Syntax, ImmutableArray(Of IOperation).Empty)
+            Return OperationFactory.CreateInvalidExpression(_semanticModel, [operator].UnderlyingExpression.Syntax, ImmutableArray(Of IOperation).Empty)
         End Function
 
         Private Shared Function GetUserDefinedBinaryOperatorChildBoundNode([operator] As BoundUserDefinedBinaryOperator, index As Integer) As BoundNode
@@ -82,6 +82,7 @@ Namespace Microsoft.CodeAnalysis.Semantics
                         value,
                         Create(byRefArgument.InConversion),
                         Create(byRefArgument.OutConversion),
+                        _semanticModel,
                         value.Syntax,
                         type:=Nothing,
                         constantValue:=Nothing)
@@ -102,6 +103,7 @@ Namespace Microsoft.CodeAnalysis.Semantics
                             value,
                             inConversion:=Nothing,
                             outConversion:=Nothing,
+                            semanticModel:=_semanticModel,
                             syntax:=value.Syntax,
                             type:=Nothing,
                             constantValue:=Nothing)
@@ -120,6 +122,7 @@ Namespace Microsoft.CodeAnalysis.Semantics
                             value,
                             inConversion:=Nothing,
                             outConversion:=Nothing,
+                            semanticModel:=_semanticModel,
                             syntax:=value.Syntax,
                             type:=Nothing,
                             constantValue:=Nothing)
@@ -137,7 +140,7 @@ Namespace Microsoft.CodeAnalysis.Semantics
                 Return child
             End If
 
-            Return OperationFactory.CreateInvalidExpression(parent.Syntax, ImmutableArray(Of IOperation).Empty)
+            Return OperationFactory.CreateInvalidExpression(_semanticModel, parent.Syntax, ImmutableArray(Of IOperation).Empty)
         End Function
 
         Private Shared Function GetChildOfBadExpressionBoundNode(parent As BoundNode, index As Integer) As BoundNode
@@ -171,7 +174,7 @@ Namespace Microsoft.CodeAnalysis.Semantics
                 Dim syntax As SyntaxNode = If(value.Syntax?.Parent, expression.Syntax)
                 Dim type As ITypeSymbol = target.Type
                 Dim constantValue As [Optional](Of Object) = value.ConstantValue
-                Dim assignment = New SimpleAssignmentExpression(target, value, syntax, type, constantValue)
+                Dim assignment = New SimpleAssignmentExpression(target, value, _semanticModel, syntax, type, constantValue)
                 builder.Add(assignment)
             Next i
 
@@ -188,7 +191,8 @@ Namespace Microsoft.CodeAnalysis.Semantics
                     If caseStatement.CaseClauses.IsEmpty AndAlso caseStatement.Syntax.Kind() = SyntaxKind.CaseElseStatement Then
                         clauses = ImmutableArray.Create(Of ICaseClause)(
                                                                     New DefaultCaseClause(
-                                                                        syntax:=caseStatement.Syntax,
+                                                                        _semanticModel,
+                                                                        caseStatement.Syntax,
                                                                         type:=Nothing,
                                                                         constantValue:=Nothing))
                     Else
@@ -197,7 +201,7 @@ Namespace Microsoft.CodeAnalysis.Semantics
 
                     Dim body = ImmutableArray.Create(Create(boundCaseBlock.Body))
                     Dim syntax = boundCaseBlock.Syntax
-                    Return DirectCast(New SwitchCase(clauses, body, syntax, type:=Nothing, constantValue:=Nothing), ISwitchCase)
+                    Return DirectCast(New SwitchCase(clauses, body, _semanticModel, syntax, type:=Nothing, constantValue:=Nothing), ISwitchCase)
                 End Function)
         End Function
 
@@ -257,7 +261,7 @@ Namespace Microsoft.CodeAnalysis.Semantics
             ' ControlVariable = InitialValue
             Dim controlReference As IOperation = Create(boundFor.ControlVariable)
             If controlReference IsNot Nothing Then
-                statements.Add(OperationFactory.CreateSimpleAssignmentExpressionStatement(controlReference, Create(boundFor.InitialValue), boundFor.InitialValue.Syntax))
+                statements.Add(OperationFactory.CreateSimpleAssignmentExpressionStatement(controlReference, Create(boundFor.InitialValue), _semanticModel, boundFor.InitialValue.Syntax))
             End If
 
             ' T0 = LimitValue
@@ -268,9 +272,10 @@ Namespace Microsoft.CodeAnalysis.Semantics
                                     New SyntheticLocalReferenceExpression(
                                             SyntheticLocalKind.ForLoopLimitValue,
                                             Create(boundFor),
-                                            syntax:=value.Syntax,
-                                            type:=value.Type,
-                                            constantValue:=Nothing), value, value.Syntax))
+                                            _semanticModel,
+                                            value.Syntax,
+                                            value.Type,
+                                            constantValue:=Nothing), value, _semanticModel, value.Syntax))
             End If
 
             ' T1 = StepValue
@@ -281,9 +286,10 @@ Namespace Microsoft.CodeAnalysis.Semantics
                                     New SyntheticLocalReferenceExpression(
                                         SyntheticLocalKind.ForLoopStepValue,
                                         Create(boundFor),
-                                        syntax:=value.Syntax,
-                                        type:=value.Type,
-                                        constantValue:=Nothing), value, value.Syntax))
+                                        _semanticModel,
+                                        value.Syntax,
+                                        value.Type,
+                                        constantValue:=Nothing), value, _semanticModel, value.Syntax))
             End If
 
             Return statements.ToImmutableAndFree()
@@ -311,10 +317,11 @@ Namespace Microsoft.CodeAnalysis.Semantics
                                         New SyntheticLocalReferenceExpression(
                                             SyntheticLocalKind.ForLoopStepValue,
                                             Create(boundFor),
-                                            syntax:=value.Syntax,
-                                            type:=value.Type,
+                                            _semanticModel,
+                                            value.Syntax,
+                                            value.Type,
                                             constantValue:=Nothing))
-                    statements.Add(OperationFactory.CreateCompoundAssignmentExpressionStatement(controlReference, stepOperand, Semantics.Expression.DeriveAdditionKind(controlType), Nothing, stepValue.Syntax))
+                    statements.Add(OperationFactory.CreateCompoundAssignmentExpressionStatement(controlReference, stepOperand, Semantics.Expression.DeriveAdditionKind(controlType), Nothing, _semanticModel, stepValue.Syntax))
                 End If
             End If
 
@@ -329,8 +336,9 @@ Namespace Microsoft.CodeAnalysis.Semantics
                             New SyntheticLocalReferenceExpression(
                                 SyntheticLocalKind.ForLoopLimitValue,
                                 Create(boundFor),
-                                syntax:=operationValue.Syntax,
-                                type:=operationValue.Type,
+                                _semanticModel,
+                                operationValue.Syntax,
+                                operationValue.Type,
                                 constantValue:=Nothing))
 
             Dim controlVariable As BoundExpression = boundFor.ControlVariable
@@ -347,7 +355,7 @@ Namespace Microsoft.CodeAnalysis.Semantics
                     ' Either ControlVariable <= LimitValue or ControlVariable >= LimitValue, depending on whether the step value is negative.
 
                     Dim relationalCode As BinaryOperationKind = Helper.DeriveBinaryOperationKind(If(boundFor.StepValue IsNot Nothing AndAlso boundFor.StepValue.ConstantValueOpt.IsNegativeNumeric, BinaryOperatorKind.GreaterThanOrEqual, BinaryOperatorKind.LessThanOrEqual), controlVariable)
-                    Return OperationFactory.CreateBinaryOperatorExpression(relationalCode, Create(controlVariable), limitValue, booleanType, limitValue.Syntax)
+                    Return OperationFactory.CreateBinaryOperatorExpression(relationalCode, Create(controlVariable), limitValue, booleanType, _semanticModel, limitValue.Syntax)
                 Else
                     ' If(StepValue >= 0, ControlVariable <= LimitValue, ControlVariable >= LimitValue)
 
@@ -355,24 +363,26 @@ Namespace Microsoft.CodeAnalysis.Semantics
                     Dim stepValue As IOperation = New SyntheticLocalReferenceExpression(
                                 SyntheticLocalKind.ForLoopStepValue,
                                 Create(boundFor),
-                                syntax:=value.Syntax,
-                                type:=value.Type,
+                                _semanticModel,
+                                value.Syntax,
+                                value.Type,
                                 constantValue:=Nothing)
 
                     Dim stepRelationalCode As BinaryOperationKind = Helper.DeriveBinaryOperationKind(BinaryOperatorKind.GreaterThanOrEqual, boundFor.StepValue)
                     Dim stepCondition As IOperation = OperationFactory.CreateBinaryOperatorExpression(stepRelationalCode,
                                  stepValue,
-                                 OperationFactory.CreateLiteralExpression(Semantics.Expression.SynthesizeNumeric(stepValue.Type, 0), boundFor.StepValue.Type, boundFor.StepValue.Syntax),
+                                 OperationFactory.CreateLiteralExpression(Semantics.Expression.SynthesizeNumeric(stepValue.Type, 0), boundFor.StepValue.Type, _semanticModel, boundFor.StepValue.Syntax),
                                  booleanType,
+                                 _semanticModel,
                                  boundFor.StepValue.Syntax)
 
                     Dim positiveStepRelationalCode As BinaryOperationKind = Helper.DeriveBinaryOperationKind(BinaryOperatorKind.LessThanOrEqual, controlVariable)
-                    Dim positiveStepCondition As IOperation = OperationFactory.CreateBinaryOperatorExpression(positiveStepRelationalCode, Create(controlVariable), limitValue, booleanType, limitValue.Syntax)
+                    Dim positiveStepCondition As IOperation = OperationFactory.CreateBinaryOperatorExpression(positiveStepRelationalCode, Create(controlVariable), limitValue, booleanType, _semanticModel, limitValue.Syntax)
 
                     Dim negativeStepRelationalCode As BinaryOperationKind = Helper.DeriveBinaryOperationKind(BinaryOperatorKind.GreaterThanOrEqual, controlVariable)
-                    Dim negativeStepCondition As IOperation = OperationFactory.CreateBinaryOperatorExpression(negativeStepRelationalCode, Create(controlVariable), limitValue, booleanType, limitValue.Syntax)
+                    Dim negativeStepCondition As IOperation = OperationFactory.CreateBinaryOperatorExpression(negativeStepRelationalCode, Create(controlVariable), limitValue, booleanType, _semanticModel, limitValue.Syntax)
 
-                    Return OperationFactory.CreateConditionalChoiceExpression(stepCondition, positiveStepCondition, negativeStepCondition, booleanType, limitValue.Syntax)
+                    Return OperationFactory.CreateConditionalChoiceExpression(stepCondition, positiveStepCondition, negativeStepCondition, booleanType, _semanticModel, limitValue.Syntax)
                 End If
             End If
         End Function
@@ -382,11 +392,11 @@ Namespace Microsoft.CodeAnalysis.Semantics
             For Each base In statement.LocalDeclarations
                 If base.Kind = BoundKind.LocalDeclaration Then
                     Dim declaration = DirectCast(base, BoundLocalDeclaration)
-                    builder.Add(OperationFactory.CreateVariableDeclaration(declaration.LocalSymbol, Create(declaration.InitializerOpt), declaration.Syntax))
+                    builder.Add(OperationFactory.CreateVariableDeclaration(declaration.LocalSymbol, Create(declaration.InitializerOpt), _semanticModel, declaration.Syntax))
                 ElseIf base.Kind = BoundKind.AsNewLocalDeclarations Then
                     Dim asNewDeclarations = DirectCast(base, BoundAsNewLocalDeclarations)
                     Dim localSymbols = asNewDeclarations.LocalDeclarations.SelectAsArray(Of ILocalSymbol)(Function(declaration) declaration.LocalSymbol)
-                    builder.Add(OperationFactory.CreateVariableDeclaration(localSymbols, Create(asNewDeclarations.Initializer), asNewDeclarations.Syntax))
+                    builder.Add(OperationFactory.CreateVariableDeclaration(localSymbols, Create(asNewDeclarations.Initializer), _semanticModel, asNewDeclarations.Syntax))
                 End If
             Next
 
@@ -401,7 +411,8 @@ Namespace Microsoft.CodeAnalysis.Semantics
             Dim syntax = DirectCast(boundUsing.Syntax, UsingBlockSyntax).UsingStatement
             Return New VariableDeclarationStatement(
                             declaration,
-                            syntax:=syntax,
+                            _semanticModel,
+                            syntax,
                             type:=Nothing,
                             constantValue:=Nothing)
         End Function
@@ -412,7 +423,7 @@ Namespace Microsoft.CodeAnalysis.Semantics
             Dim instance = If([event] Is Nothing OrElse [event].IsStatic, Nothing, If(eventAccess IsNot Nothing, Create(eventAccess.ReceiverOpt), Nothing))
 
             Return New EventAssignmentExpression(
-                        [event], instance, Create(statement.Handler), adds:=True, syntax:=statement.Syntax, type:=Nothing, constantValue:=Nothing)
+                        [event], instance, Create(statement.Handler), adds:=True, semanticModel:=_semanticModel, syntax:=statement.Syntax, type:=Nothing, constantValue:=Nothing)
         End Function
 
         Private Function GetRemoveStatementExpression(statement As BoundRemoveHandlerStatement) As IOperation
@@ -421,7 +432,7 @@ Namespace Microsoft.CodeAnalysis.Semantics
             Dim instance = If([event] Is Nothing OrElse [event].IsStatic, Nothing, If(eventAccess IsNot Nothing, Create(eventAccess.ReceiverOpt), Nothing))
 
             Return New EventAssignmentExpression(
-                [event], instance, Create(statement.Handler), adds:=False, syntax:=statement.Syntax, type:=Nothing, constantValue:=Nothing)
+                [event], instance, Create(statement.Handler), adds:=False, semanticModel:=_semanticModel, syntax:=statement.Syntax, type:=Nothing, constantValue:=Nothing)
         End Function
 
         Private Shared Function GetConversionKind(kind As VisualBasic.ConversionKind) As Semantics.ConversionKind

src/Test/Utilities/Portable/Diagnostics/CouldHaveMoreSpecificTypeAnalyzer.cs

@@ -65,7 +65,7 @@ public sealed override void Initialize(AnalysisContext context)
                                            SyntaxNode syntax = increment.Syntax;
                                            ITypeSymbol type = increment.Type;
                                            Optional<object> constantValue = new Optional<object>(1);
-                                           var value = new LiteralExpression(text, syntax, type, constantValue);
+                                           var value = new LiteralExpression(text, operationContext.Compilation.GetSemanticModel(syntax.SyntaxTree), syntax, type, constantValue);
 
                                            AssignTo(increment.Target, localsSourceTypes, fieldsSourceTypes, value);
                                        }

src/Test/Utilities/Portable/Diagnostics/OperationTestAnalyzer.cs

@@ -181,10 +181,11 @@ private void AnalyzeOperation(OperationAnalysisContext operationContext)
                                         if (advance.Kind == OperationKind.ExpressionStatement)
                                         {
                                             IOperation advanceExpression = ((IExpressionStatement)advance).Expression;
+                                            SemanticModel semanticModel = operationContext.Compilation.GetSemanticModel(advance.Syntax.SyntaxTree);
 
                                             IOperation advanceIncrement;
                                             BinaryOperationKind advanceOperationCode;
-                                            GetOperationKindAndValue(testVariable, advanceExpression, out advanceOperationCode, out advanceIncrement);
+                                            GetOperationKindAndValue(semanticModel, testVariable, advanceExpression, out advanceOperationCode, out advanceIncrement);
 
                                             if (advanceIncrement != null)
                                             {
@@ -221,7 +222,7 @@ private void AnalyzeOperation(OperationAnalysisContext operationContext)
         }
 
         private void GetOperationKindAndValue(
-            ILocalSymbol testVariable, IOperation advanceExpression,
+            SemanticModel semanticModel, ILocalSymbol testVariable, IOperation advanceExpression,
             out BinaryOperationKind advanceOperationCode, out IOperation advanceIncrement)
         {
             advanceIncrement = null;
@@ -273,20 +274,20 @@ private void AnalyzeOperation(OperationAnalysisContext operationContext)
                     ((ILocalReferenceExpression)advanceAssignment.Target).Local == testVariable)
                 {
                     // Advance binary operation is known to involve a reference to the local used in the test and a constant.
-                    advanceIncrement = CreateIncrementOneLiteralExpression(advanceAssignment);
+                    advanceIncrement = CreateIncrementOneLiteralExpression(semanticModel, advanceAssignment);
                     advanceOperationCode = CSharpOperationFactory.Helper.DeriveBinaryOperationKind(advanceAssignment.IncrementOperationKind);
                 }
             }
         }
 
-        private static ILiteralExpression CreateIncrementOneLiteralExpression(IIncrementExpression increment)
+        private static ILiteralExpression CreateIncrementOneLiteralExpression(SemanticModel semanticModel, IIncrementExpression increment)
         {
             string text = increment.Syntax.ToString();
             SyntaxNode syntax = increment.Syntax;
             ITypeSymbol type = increment.Type;
             Optional<object> constantValue = new Optional<object>(1);
 
-            return new LiteralExpression(text, syntax, type, constantValue);
+            return new LiteralExpression(text, semanticModel, syntax, type, constantValue);
         }
 
         private static int Abs(int value)