diff --git a/src/Compilers/CSharp/Portable/Operations/CSharpConversionExpression.cs b/src/Compilers/CSharp/Portable/Operations/CSharpConversionExpression.cs index e73841ddd389ce2266f5650f15b78e33489e964e..27fbede93d0bbbe063b44748213a9ea08971d878 100644 --- a/src/Compilers/CSharp/Portable/Operations/CSharpConversionExpression.cs +++ b/src/Compilers/CSharp/Portable/Operations/CSharpConversionExpression.cs @@ -7,8 +7,8 @@ namespace Microsoft.CodeAnalysis.CSharp { internal abstract class BaseCSharpConversionExpression : BaseConversionExpression { - protected BaseCSharpConversionExpression(Conversion conversion, bool isExplicitInCode, bool isTryCast, bool isChecked, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(isExplicitInCode, isTryCast, isChecked, semanticModel, syntax, type, constantValue) + protected BaseCSharpConversionExpression(Conversion conversion, bool isExplicitInCode, bool isTryCast, bool isChecked, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(isExplicitInCode, isTryCast, isChecked, semanticModel, syntax, type, constantValue, isImplicit) { ConversionInternal = conversion; } @@ -20,8 +20,8 @@ internal abstract class BaseCSharpConversionExpression : BaseConversionExpressio internal sealed partial class CSharpConversionExpression : BaseCSharpConversionExpression { - public CSharpConversionExpression(IOperation operand, Conversion conversion, bool isExplicit, bool isTryCast, bool isChecked, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(conversion, isExplicit, isTryCast, isChecked, semanticModel, syntax, type, constantValue) + public CSharpConversionExpression(IOperation operand, Conversion conversion, bool isExplicit, bool isTryCast, bool isChecked, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(conversion, isExplicit, isTryCast, isChecked, semanticModel, syntax, type, constantValue, isImplicit) { OperandImpl = operand; } @@ -32,8 +32,8 @@ internal sealed partial class CSharpConversionExpression : BaseCSharpConversionE internal sealed partial class LazyCSharpConversionExpression : BaseCSharpConversionExpression { private readonly Lazy _operand; - public LazyCSharpConversionExpression(Lazy operand, Conversion conversion, bool isExplicit, bool isTryCast, bool isChecked, SemanticModel semanticModel,SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(conversion, isExplicit, isTryCast, isChecked, semanticModel, syntax, type, constantValue) + public LazyCSharpConversionExpression(Lazy operand, Conversion conversion, bool isExplicit, bool isTryCast, bool isChecked, SemanticModel semanticModel,SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(conversion, isExplicit, isTryCast, isChecked, semanticModel, syntax, type, constantValue, isImplicit) { _operand = operand; } diff --git a/src/Compilers/CSharp/Portable/Operations/CSharpOperationCloner.cs b/src/Compilers/CSharp/Portable/Operations/CSharpOperationCloner.cs index 72551d490a08031a40a70d0d862568803992d76a..bb27fab2eba421235aa42bb2763fa34d907f2c18 100644 --- a/src/Compilers/CSharp/Portable/Operations/CSharpOperationCloner.cs +++ b/src/Compilers/CSharp/Portable/Operations/CSharpOperationCloner.cs @@ -10,7 +10,7 @@ internal class CSharpOperationCloner : OperationCloner public override IOperation VisitConversionExpression(IConversionExpression operation, object argument) { - return new CSharpConversionExpression(Visit(operation.Operand), operation.GetConversion(), operation.IsExplicitInCode, operation.IsTryCast, operation.IsChecked, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new CSharpConversionExpression(Visit(operation.Operand), operation.GetConversion(), operation.IsExplicitInCode, operation.IsTryCast, operation.IsChecked, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } } } diff --git a/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs b/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs index a362a93b2f8aa19851498620f9d5aa9ba2bdd691..711e3462082872e53c541ee2f070526d1b2fba0f 100644 --- a/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs +++ b/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs @@ -256,7 +256,9 @@ private IOperation CreateInternal(BoundNode boundNode) return CreateBoundIsPatternExpressionOperation((BoundIsPatternExpression)boundNode); default: var constantValue = ConvertToOptional((boundNode as BoundExpression)?.ConstantValue); - return Operation.CreateOperationNone(_semanticModel, boundNode.Syntax, constantValue, getChildren: () => GetIOperationChildren(boundNode)); + bool isImplicit = boundNode.WasCompilerGenerated; + + return Operation.CreateOperationNone(_semanticModel, boundNode.Syntax, constantValue, getChildren: () => GetIOperationChildren(boundNode), isImplicit: isImplicit); } } @@ -283,7 +285,8 @@ private IPlaceholderExpression CreateBoundDeconstructValuePlaceholderOperation(B SyntaxNode syntax = boundDeconstructValuePlaceholder.Syntax; ITypeSymbol type = boundDeconstructValuePlaceholder.Type; Optional constantValue = ConvertToOptional(boundDeconstructValuePlaceholder.ConstantValue); - return new PlaceholderExpression(_semanticModel, syntax, type, constantValue); + bool isImplicit = boundDeconstructValuePlaceholder.WasCompilerGenerated; + return new PlaceholderExpression(_semanticModel, syntax, type, constantValue, isImplicit); } private IInvocationExpression CreateBoundCallOperation(BoundCall boundCall) @@ -313,7 +316,8 @@ private IInvocationExpression CreateBoundCallOperation(BoundCall boundCall) SyntaxNode syntax = boundCall.Syntax; ITypeSymbol type = boundCall.Type; Optional constantValue = ConvertToOptional(boundCall.ConstantValue); - return new LazyInvocationExpression(targetMethod, instance, isVirtual, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundCall.WasCompilerGenerated; + return new LazyInvocationExpression(targetMethod, instance, isVirtual, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue, isImplicit); } private ILocalReferenceExpression CreateBoundLocalOperation(BoundLocal boundLocal) @@ -322,7 +326,8 @@ private ILocalReferenceExpression CreateBoundLocalOperation(BoundLocal boundLoca SyntaxNode syntax = boundLocal.Syntax; ITypeSymbol type = boundLocal.Type; Optional constantValue = ConvertToOptional(boundLocal.ConstantValue); - return new LocalReferenceExpression(local, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundLocal.WasCompilerGenerated; + return new LocalReferenceExpression(local, _semanticModel, syntax, type, constantValue, isImplicit); } private IFieldReferenceExpression CreateBoundFieldAccessOperation(BoundFieldAccess boundFieldAccess) @@ -333,7 +338,8 @@ private IFieldReferenceExpression CreateBoundFieldAccessOperation(BoundFieldAcce SyntaxNode syntax = boundFieldAccess.Syntax; ITypeSymbol type = boundFieldAccess.Type; Optional constantValue = ConvertToOptional(boundFieldAccess.ConstantValue); - return new LazyFieldReferenceExpression(field, instance, member, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundFieldAccess.WasCompilerGenerated; + return new LazyFieldReferenceExpression(field, instance, member, _semanticModel, syntax, type, constantValue, isImplicit); } private IPropertyReferenceExpression CreateBoundPropertyAccessOperation(BoundPropertyAccess boundPropertyAccess) @@ -345,7 +351,8 @@ private IPropertyReferenceExpression CreateBoundPropertyAccessOperation(BoundPro SyntaxNode syntax = boundPropertyAccess.Syntax; ITypeSymbol type = boundPropertyAccess.Type; Optional constantValue = ConvertToOptional(boundPropertyAccess.ConstantValue); - return new LazyPropertyReferenceExpression(property, instance, member, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundPropertyAccess.WasCompilerGenerated; + return new LazyPropertyReferenceExpression(property, instance, member, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue, isImplicit); } private IPropertyReferenceExpression CreateBoundIndexerAccessOperation(BoundIndexerAccess boundIndexerAccess) @@ -375,7 +382,8 @@ private IPropertyReferenceExpression CreateBoundIndexerAccessOperation(BoundInde SyntaxNode syntax = boundIndexerAccess.Syntax; ITypeSymbol type = boundIndexerAccess.Type; Optional constantValue = ConvertToOptional(boundIndexerAccess.ConstantValue); - return new LazyPropertyReferenceExpression(property, instance, member, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundIndexerAccess.WasCompilerGenerated; + return new LazyPropertyReferenceExpression(property, instance, member, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue, isImplicit); } private IEventReferenceExpression CreateBoundEventAccessOperation(BoundEventAccess boundEventAccess) @@ -386,7 +394,8 @@ private IEventReferenceExpression CreateBoundEventAccessOperation(BoundEventAcce SyntaxNode syntax = boundEventAccess.Syntax; ITypeSymbol type = boundEventAccess.Type; Optional constantValue = ConvertToOptional(boundEventAccess.ConstantValue); - return new LazyEventReferenceExpression(@event, instance, member, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundEventAccess.WasCompilerGenerated; + return new LazyEventReferenceExpression(@event, instance, member, _semanticModel, syntax, type, constantValue, isImplicit); } private IEventReferenceExpression CreateBoundEventAccessOperation(BoundEventAssignmentOperator boundEventAssignmentOperator) @@ -400,28 +409,31 @@ private IEventReferenceExpression CreateBoundEventAccessOperation(BoundEventAssi IEventSymbol @event = boundEventAssignmentOperator.Event; Lazy instance = new Lazy(() => Create(boundEventAssignmentOperator.Event.IsStatic ? null : boundEventAssignmentOperator.ReceiverOpt)); SyntaxNode eventAccessSyntax = ((AssignmentExpressionSyntax)syntax).Left; + bool isImplicit = boundEventAssignmentOperator.WasCompilerGenerated; - return new LazyEventReferenceExpression(@event, instance, @event, _semanticModel, eventAccessSyntax, @event.Type, ConvertToOptional(null)); + return new LazyEventReferenceExpression(@event, instance, @event, _semanticModel, eventAccessSyntax, @event.Type, ConvertToOptional(null), isImplicit); } private IEventAssignmentExpression CreateBoundEventAssignmentOperatorOperation(BoundEventAssignmentOperator boundEventAssignmentOperator) { - Lazy eventReference = new Lazy(() => CreateBoundEventAccessOperation(boundEventAssignmentOperator)); + Lazy eventReference = new Lazy(() => CreateBoundEventAccessOperation(boundEventAssignmentOperator)); Lazy handlerValue = new Lazy(() => Create(boundEventAssignmentOperator.Argument)); SyntaxNode syntax = boundEventAssignmentOperator.Syntax; bool adds = boundEventAssignmentOperator.IsAddition; ITypeSymbol type = boundEventAssignmentOperator.Type; Optional constantValue = ConvertToOptional(boundEventAssignmentOperator.ConstantValue); - return new LazyEventAssignmentExpression(eventReference, handlerValue, adds, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundEventAssignmentOperator.WasCompilerGenerated; + return new LazyEventAssignmentExpression(eventReference, handlerValue, adds, _semanticModel, syntax, type, constantValue, isImplicit); } - private IParameterReferenceExpression CreateBoundParameterOperation(BoundParameter boundParameter) + private IParameterReferenceExpression CreateBoundParameterOperation(BoundParameter boundParameter) { IParameterSymbol parameter = boundParameter.ParameterSymbol; SyntaxNode syntax = boundParameter.Syntax; ITypeSymbol type = boundParameter.Type; Optional constantValue = ConvertToOptional(boundParameter.ConstantValue); - return new ParameterReferenceExpression(parameter, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundParameter.WasCompilerGenerated; + return new ParameterReferenceExpression(parameter, _semanticModel, syntax, type, constantValue, isImplicit); } private ILiteralExpression CreateBoundLiteralOperation(BoundLiteral boundLiteral) @@ -430,7 +442,8 @@ private ILiteralExpression CreateBoundLiteralOperation(BoundLiteral boundLiteral SyntaxNode syntax = boundLiteral.Syntax; ITypeSymbol type = boundLiteral.Type; Optional constantValue = ConvertToOptional(boundLiteral.ConstantValue); - return new LiteralExpression(text, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundLiteral.WasCompilerGenerated; + return new LiteralExpression(text, _semanticModel, syntax, type, constantValue, isImplicit); } private IAnonymousObjectCreationExpression CreateBoundAnonymousObjectCreationExpressionOperation(BoundAnonymousObjectCreationExpression boundAnonymousObjectCreationExpression) @@ -439,7 +452,8 @@ private IAnonymousObjectCreationExpression CreateBoundAnonymousObjectCreationExp SyntaxNode syntax = boundAnonymousObjectCreationExpression.Syntax; ITypeSymbol type = boundAnonymousObjectCreationExpression.Type; Optional constantValue = ConvertToOptional(boundAnonymousObjectCreationExpression.ConstantValue); - return new LazyAnonymousObjectCreationExpression(memberInitializers, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundAnonymousObjectCreationExpression.WasCompilerGenerated; + return new LazyAnonymousObjectCreationExpression(memberInitializers, _semanticModel, syntax, type, constantValue, isImplicit); } private IPropertyReferenceExpression CreateBoundAnonymousPropertyDeclarationOperation(BoundAnonymousPropertyDeclaration boundAnonymousPropertyDeclaration) @@ -451,7 +465,8 @@ private IPropertyReferenceExpression CreateBoundAnonymousPropertyDeclarationOper SyntaxNode syntax = boundAnonymousPropertyDeclaration.Syntax; ITypeSymbol type = boundAnonymousPropertyDeclaration.Type; Optional constantValue = ConvertToOptional(boundAnonymousPropertyDeclaration.ConstantValue); - return new LazyPropertyReferenceExpression(property, instance, member, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundAnonymousPropertyDeclaration.WasCompilerGenerated; + return new LazyPropertyReferenceExpression(property, instance, member, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue, isImplicit); } private IObjectCreationExpression CreateBoundObjectCreationExpressionOperation(BoundObjectCreationExpression boundObjectCreationExpression) @@ -476,7 +491,8 @@ private IObjectCreationExpression CreateBoundObjectCreationExpressionOperation(B SyntaxNode syntax = boundObjectCreationExpression.Syntax; ITypeSymbol type = boundObjectCreationExpression.Type; Optional constantValue = ConvertToOptional(boundObjectCreationExpression.ConstantValue); - return new LazyObjectCreationExpression(constructor, initializer, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundObjectCreationExpression.WasCompilerGenerated; + return new LazyObjectCreationExpression(constructor, initializer, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue, isImplicit); } private IDynamicObjectCreationExpression CreateBoundDynamicObjectCreationExpressionOperation(BoundDynamicObjectCreationExpression boundDynamicObjectCreationExpression) @@ -490,7 +506,8 @@ private IDynamicObjectCreationExpression CreateBoundDynamicObjectCreationExpress SyntaxNode syntax = boundDynamicObjectCreationExpression.Syntax; ITypeSymbol type = boundDynamicObjectCreationExpression.Type; Optional constantValue = ConvertToOptional(boundDynamicObjectCreationExpression.ConstantValue); - return new LazyDynamicObjectCreationExpression(name, applicableSymbols, arguments, argumentNames, argumentRefKinds, initializer, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundDynamicObjectCreationExpression.WasCompilerGenerated; + return new LazyDynamicObjectCreationExpression(name, applicableSymbols, arguments, argumentNames, argumentRefKinds, initializer, _semanticModel, syntax, type, constantValue, isImplicit); } private IObjectOrCollectionInitializerExpression CreateBoundObjectInitializerExpressionOperation(BoundObjectInitializerExpression boundObjectInitializerExpression) @@ -499,7 +516,8 @@ private IObjectOrCollectionInitializerExpression CreateBoundObjectInitializerExp SyntaxNode syntax = boundObjectInitializerExpression.Syntax; ITypeSymbol type = boundObjectInitializerExpression.Type; Optional constantValue = ConvertToOptional(boundObjectInitializerExpression.ConstantValue); - return new LazyObjectOrCollectionInitializerExpression(initializers, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundObjectInitializerExpression.WasCompilerGenerated; + return new LazyObjectOrCollectionInitializerExpression(initializers, _semanticModel, syntax, type, constantValue, isImplicit); } private IObjectOrCollectionInitializerExpression CreateBoundCollectionInitializerExpressionOperation(BoundCollectionInitializerExpression boundCollectionInitializerExpression) @@ -508,7 +526,8 @@ private IObjectOrCollectionInitializerExpression CreateBoundCollectionInitialize SyntaxNode syntax = boundCollectionInitializerExpression.Syntax; ITypeSymbol type = boundCollectionInitializerExpression.Type; Optional constantValue = ConvertToOptional(boundCollectionInitializerExpression.ConstantValue); - return new LazyObjectOrCollectionInitializerExpression(initializers, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundCollectionInitializerExpression.WasCompilerGenerated; + return new LazyObjectOrCollectionInitializerExpression(initializers, _semanticModel, syntax, type, constantValue, isImplicit); } private IMemberReferenceExpression CreateBoundObjectInitializerMemberOperation(BoundObjectInitializerMember boundObjectInitializerMember) @@ -518,20 +537,22 @@ private IMemberReferenceExpression CreateBoundObjectInitializerMemberOperation(B _semanticModel, syntax: boundObjectInitializerMember.Syntax, type: boundObjectInitializerMember.MemberSymbol.ContainingType, - constantValue: default(Optional))); + constantValue: default(Optional), + isImplicit: boundObjectInitializerMember.WasCompilerGenerated)); SyntaxNode syntax = boundObjectInitializerMember.Syntax; ITypeSymbol type = boundObjectInitializerMember.Type; Optional constantValue = ConvertToOptional(boundObjectInitializerMember.ConstantValue); + bool isImplicit = boundObjectInitializerMember.WasCompilerGenerated; switch (boundObjectInitializerMember.MemberSymbol.Kind) { case SymbolKind.Field: var field = (FieldSymbol)boundObjectInitializerMember.MemberSymbol; - return new LazyFieldReferenceExpression(field, instance, field, _semanticModel, syntax, type, constantValue); + return new LazyFieldReferenceExpression(field, instance, field, _semanticModel, syntax, type, constantValue, isImplicit); case SymbolKind.Event: var eventSymbol = (EventSymbol)boundObjectInitializerMember.MemberSymbol; - return new LazyEventReferenceExpression(eventSymbol, instance, eventSymbol, _semanticModel, syntax, type, constantValue); + return new LazyEventReferenceExpression(eventSymbol, instance, eventSymbol, _semanticModel, syntax, type, constantValue, isImplicit); case SymbolKind.Property: var property = (PropertySymbol)boundObjectInitializerMember.MemberSymbol; Lazy> argumentsInEvaluationOrder; @@ -560,7 +581,7 @@ private IMemberReferenceExpression CreateBoundObjectInitializerMemberOperation(B }); } - return new LazyPropertyReferenceExpression(property, instance, property, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue); + return new LazyPropertyReferenceExpression(property, instance, property, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue, isImplicit); default: throw ExceptionUtilities.Unreachable; } @@ -574,7 +595,8 @@ private ICollectionElementInitializerExpression CreateBoundCollectionElementInit SyntaxNode syntax = boundCollectionElementInitializer.Syntax; ITypeSymbol type = boundCollectionElementInitializer.Type; Optional constantValue = ConvertToOptional(boundCollectionElementInitializer.ConstantValue); - return new LazyCollectionElementInitializerExpression(addMethod, arguments, isDynamic, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundCollectionElementInitializer.WasCompilerGenerated; + return new LazyCollectionElementInitializerExpression(addMethod, arguments, isDynamic, _semanticModel, syntax, type, constantValue, isImplicit); } private IDynamicMemberReferenceExpression CreateBoundDynamicMemberAccessOperation(BoundDynamicMemberAccess boundDynamicMemberAccess) @@ -590,7 +612,8 @@ private IDynamicMemberReferenceExpression CreateBoundDynamicMemberAccessOperatio SyntaxNode syntaxNode = boundDynamicMemberAccess.Syntax; ITypeSymbol type = boundDynamicMemberAccess.Type; Optional constantValue = ConvertToOptional(boundDynamicMemberAccess.ConstantValue); - return new LazyDynamicMemberReferenceExpression(instance, memberName, typeArguments, containingType, _semanticModel, syntaxNode, type, constantValue); + bool isImplicit = boundDynamicMemberAccess.WasCompilerGenerated; + return new LazyDynamicMemberReferenceExpression(instance, memberName, typeArguments, containingType, _semanticModel, syntaxNode, type, constantValue, isImplicit); } private ICollectionElementInitializerExpression CreateBoundDynamicCollectionElementInitializerOperation(BoundDynamicCollectionElementInitializer boundCollectionElementInitializer) @@ -601,7 +624,8 @@ private ICollectionElementInitializerExpression CreateBoundDynamicCollectionElem SyntaxNode syntax = boundCollectionElementInitializer.Syntax; ITypeSymbol type = boundCollectionElementInitializer.Type; Optional constantValue = ConvertToOptional(boundCollectionElementInitializer.ConstantValue); - return new LazyCollectionElementInitializerExpression(addMethod, arguments, isDynamic, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundCollectionElementInitializer.WasCompilerGenerated; + return new LazyCollectionElementInitializerExpression(addMethod, arguments, isDynamic, _semanticModel, syntax, type, constantValue, isImplicit); } private IOperation CreateUnboundLambdaOperation(UnboundLambda unboundLambda) @@ -626,7 +650,8 @@ private ILambdaExpression CreateBoundLambdaOperation(BoundLambda boundLambda) // an ILambdaExpression, you need to look at the parent IConversionExpression. ITypeSymbol type = null; Optional constantValue = ConvertToOptional(boundLambda.ConstantValue); - return new LazyLambdaExpression(signature, body, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundLambda.WasCompilerGenerated; + return new LazyLambdaExpression(signature, body, _semanticModel, syntax, type, constantValue, isImplicit); } private ILocalFunctionStatement CreateBoundLocalFunctionStatementOperation(BoundLocalFunctionStatement boundLocalFunctionStatement) @@ -636,12 +661,14 @@ private ILocalFunctionStatement CreateBoundLocalFunctionStatementOperation(Bound SyntaxNode syntax = boundLocalFunctionStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyLocalFunctionStatement(localFunctionSymbol, body, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundLocalFunctionStatement.WasCompilerGenerated; + return new LazyLocalFunctionStatement(localFunctionSymbol, body, _semanticModel, syntax, type, constantValue, isImplicit); } private IOperation CreateBoundConversionOperation(BoundConversion boundConversion) { ConversionKind conversionKind = GetConversionKind(boundConversion.ConversionKind); + bool isImplicit = boundConversion.WasCompilerGenerated; if (boundConversion.ConversionKind == CSharp.ConversionKind.MethodGroup) { IMethodSymbol method = boundConversion.SymbolOpt; @@ -650,7 +677,7 @@ private IOperation CreateBoundConversionOperation(BoundConversion boundConversio SyntaxNode syntax = boundConversion.Syntax; ITypeSymbol type = boundConversion.Type; Optional constantValue = ConvertToOptional(boundConversion.ConstantValue); - return new LazyMethodBindingExpression(method, isVirtual, instance, method, _semanticModel, syntax, type, constantValue); + return new LazyMethodBindingExpression(method, isVirtual, instance, method, _semanticModel, syntax, type, constantValue, isImplicit); } else { @@ -663,7 +690,7 @@ private IOperation CreateBoundConversionOperation(BoundConversion boundConversio bool isChecked = conversion.IsNumeric && boundConversion.Checked; ITypeSymbol type = boundConversion.Type; Optional constantValue = ConvertToOptional(boundConversion.ConstantValue); - return new LazyCSharpConversionExpression(operand, conversion, isExplicit, isTryCast, isChecked, _semanticModel, syntax, type, constantValue); + return new LazyCSharpConversionExpression(operand, conversion, isExplicit, isTryCast, isChecked, _semanticModel, syntax, type, constantValue, isImplicit); } } @@ -677,7 +704,8 @@ private IConversionExpression CreateBoundAsOperatorOperation(BoundAsOperator bou bool isChecked = false; ITypeSymbol type = boundAsOperator.Type; Optional constantValue = ConvertToOptional(boundAsOperator.ConstantValue); - return new LazyCSharpConversionExpression(operand, conversion, isExplicit, isTryCast, isChecked, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundAsOperator.WasCompilerGenerated; + return new LazyCSharpConversionExpression(operand, conversion, isExplicit, isTryCast, isChecked, _semanticModel, syntax, type, constantValue, isImplicit); } private IIsTypeExpression CreateBoundIsOperatorOperation(BoundIsOperator boundIsOperator) @@ -687,7 +715,8 @@ private IIsTypeExpression CreateBoundIsOperatorOperation(BoundIsOperator boundIs SyntaxNode syntax = boundIsOperator.Syntax; ITypeSymbol type = boundIsOperator.Type; Optional constantValue = ConvertToOptional(boundIsOperator.ConstantValue); - return new LazyIsTypeExpression(operand, isType, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundIsOperator.WasCompilerGenerated; + return new LazyIsTypeExpression(operand, isType, _semanticModel, syntax, type, constantValue, isImplicit); } private ISizeOfExpression CreateBoundSizeOfOperatorOperation(BoundSizeOfOperator boundSizeOfOperator) @@ -696,7 +725,8 @@ private ISizeOfExpression CreateBoundSizeOfOperatorOperation(BoundSizeOfOperator SyntaxNode syntax = boundSizeOfOperator.Syntax; ITypeSymbol type = boundSizeOfOperator.Type; Optional constantValue = ConvertToOptional(boundSizeOfOperator.ConstantValue); - return new SizeOfExpression(typeOperand, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundSizeOfOperator.WasCompilerGenerated; + return new SizeOfExpression(typeOperand, _semanticModel, syntax, type, constantValue, isImplicit); } private ITypeOfExpression CreateBoundTypeOfOperatorOperation(BoundTypeOfOperator boundTypeOfOperator) @@ -705,7 +735,8 @@ private ITypeOfExpression CreateBoundTypeOfOperatorOperation(BoundTypeOfOperator SyntaxNode syntax = boundTypeOfOperator.Syntax; ITypeSymbol type = boundTypeOfOperator.Type; Optional constantValue = ConvertToOptional(boundTypeOfOperator.ConstantValue); - return new TypeOfExpression(typeOperand, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundTypeOfOperator.WasCompilerGenerated; + return new TypeOfExpression(typeOperand, _semanticModel, syntax, type, constantValue, isImplicit); } private IArrayCreationExpression CreateBoundArrayCreationOperation(BoundArrayCreation boundArrayCreation) @@ -716,7 +747,8 @@ private IArrayCreationExpression CreateBoundArrayCreationOperation(BoundArrayCre SyntaxNode syntax = boundArrayCreation.Syntax; ITypeSymbol type = boundArrayCreation.Type; Optional constantValue = ConvertToOptional(boundArrayCreation.ConstantValue); - return new LazyArrayCreationExpression(elementType, dimensionSizes, initializer, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundArrayCreation.WasCompilerGenerated; + return new LazyArrayCreationExpression(elementType, dimensionSizes, initializer, _semanticModel, syntax, type, constantValue, isImplicit); } private IArrayInitializer CreateBoundArrayInitializationOperation(BoundArrayInitialization boundArrayInitialization) @@ -725,7 +757,8 @@ private IArrayInitializer CreateBoundArrayInitializationOperation(BoundArrayInit SyntaxNode syntax = boundArrayInitialization.Syntax; ITypeSymbol type = boundArrayInitialization.Type; Optional constantValue = ConvertToOptional(boundArrayInitialization.ConstantValue); - return new LazyArrayInitializer(elementValues, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundArrayInitialization.WasCompilerGenerated; + return new LazyArrayInitializer(elementValues, _semanticModel, syntax, type, constantValue, isImplicit); } private IDefaultValueExpression CreateBoundDefaultExpressionOperation(BoundDefaultExpression boundDefaultExpression) @@ -733,7 +766,8 @@ private IDefaultValueExpression CreateBoundDefaultExpressionOperation(BoundDefau SyntaxNode syntax = boundDefaultExpression.Syntax; ITypeSymbol type = boundDefaultExpression.Type; Optional constantValue = ConvertToOptional(boundDefaultExpression.ConstantValue); - return new DefaultValueExpression(_semanticModel, syntax, type, constantValue); + bool isImplicit = boundDefaultExpression.WasCompilerGenerated; + return new DefaultValueExpression(_semanticModel, syntax, type, constantValue, isImplicit); } private IInstanceReferenceExpression CreateBoundBaseReferenceOperation(BoundBaseReference boundBaseReference) @@ -742,7 +776,8 @@ private IInstanceReferenceExpression CreateBoundBaseReferenceOperation(BoundBase SyntaxNode syntax = boundBaseReference.Syntax; ITypeSymbol type = boundBaseReference.Type; Optional constantValue = ConvertToOptional(boundBaseReference.ConstantValue); - return new InstanceReferenceExpression(instanceReferenceKind, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundBaseReference.WasCompilerGenerated; + return new InstanceReferenceExpression(instanceReferenceKind, _semanticModel, syntax, type, constantValue, isImplicit); } private IInstanceReferenceExpression CreateBoundThisReferenceOperation(BoundThisReference boundThisReference) @@ -751,7 +786,8 @@ private IInstanceReferenceExpression CreateBoundThisReferenceOperation(BoundThis SyntaxNode syntax = boundThisReference.Syntax; ITypeSymbol type = boundThisReference.Type; Optional constantValue = ConvertToOptional(boundThisReference.ConstantValue); - return new InstanceReferenceExpression(instanceReferenceKind, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundThisReference.WasCompilerGenerated; + return new InstanceReferenceExpression(instanceReferenceKind, _semanticModel, syntax, type, constantValue, isImplicit); } private IOperation CreateBoundAssignmentOperatorOrMemberInitializerOperation(BoundAssignmentOperator boundAssignmentOperator) @@ -773,7 +809,8 @@ private ISimpleAssignmentExpression CreateBoundAssignmentOperatorOperation(Bound SyntaxNode syntax = boundAssignmentOperator.Syntax; ITypeSymbol type = boundAssignmentOperator.Type; Optional constantValue = ConvertToOptional(boundAssignmentOperator.ConstantValue); - return new LazySimpleAssignmentExpression(target, value, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundAssignmentOperator.WasCompilerGenerated; + return new LazySimpleAssignmentExpression(target, value, _semanticModel, syntax, type, constantValue, isImplicit); } private IMemberInitializerExpression CreateBoundMemberInitializerOperation(BoundAssignmentOperator boundAssignmentOperator) @@ -785,7 +822,8 @@ private IMemberInitializerExpression CreateBoundMemberInitializerOperation(Bound SyntaxNode syntax = boundAssignmentOperator.Syntax; ITypeSymbol type = boundAssignmentOperator.Type; Optional constantValue = ConvertToOptional(boundAssignmentOperator.ConstantValue); - return new LazyMemberInitializerExpression(target, value, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundAssignmentOperator.WasCompilerGenerated; + return new LazyMemberInitializerExpression(target, value, _semanticModel, syntax, type, constantValue, isImplicit); } private ICompoundAssignmentExpression CreateBoundCompoundAssignmentOperatorOperation(BoundCompoundAssignmentOperator boundCompoundAssignmentOperator) @@ -798,7 +836,8 @@ private ICompoundAssignmentExpression CreateBoundCompoundAssignmentOperatorOpera SyntaxNode syntax = boundCompoundAssignmentOperator.Syntax; ITypeSymbol type = boundCompoundAssignmentOperator.Type; Optional constantValue = ConvertToOptional(boundCompoundAssignmentOperator.ConstantValue); - return new LazyCompoundAssignmentExpression(binaryOperationKind, boundCompoundAssignmentOperator.Type.IsNullableType(), target, value, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundCompoundAssignmentOperator.WasCompilerGenerated; + return new LazyCompoundAssignmentExpression(binaryOperationKind, boundCompoundAssignmentOperator.Type.IsNullableType(), target, value, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue, isImplicit); } private IIncrementExpression CreateBoundIncrementOperatorOperation(BoundIncrementOperator boundIncrementOperator) @@ -810,7 +849,8 @@ private IIncrementExpression CreateBoundIncrementOperatorOperation(BoundIncremen SyntaxNode syntax = boundIncrementOperator.Syntax; ITypeSymbol type = boundIncrementOperator.Type; Optional constantValue = ConvertToOptional(boundIncrementOperator.ConstantValue); - return new LazyIncrementExpression(incrementOperationKind, target, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundIncrementOperator.WasCompilerGenerated; + return new LazyIncrementExpression(incrementOperationKind, target, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue, isImplicit); } private IInvalidExpression CreateBoundBadExpressionOperation(BoundBadExpression boundBadExpression) @@ -819,7 +859,8 @@ private IInvalidExpression CreateBoundBadExpressionOperation(BoundBadExpression SyntaxNode syntax = boundBadExpression.Syntax; ITypeSymbol type = boundBadExpression.Type; Optional constantValue = ConvertToOptional(boundBadExpression.ConstantValue); - return new LazyInvalidExpression(children, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundBadExpression.WasCompilerGenerated; + return new LazyInvalidExpression(children, _semanticModel, syntax, type, constantValue, isImplicit); } private ITypeParameterObjectCreationExpression CreateBoundNewTOperation(BoundNewT boundNewT) @@ -828,7 +869,8 @@ private ITypeParameterObjectCreationExpression CreateBoundNewTOperation(BoundNew SyntaxNode syntax = boundNewT.Syntax; ITypeSymbol type = boundNewT.Type; Optional constantValue = ConvertToOptional(boundNewT.ConstantValue); - return new LazyTypeParameterObjectCreationExpression(initializer, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundNewT.WasCompilerGenerated; + return new LazyTypeParameterObjectCreationExpression(initializer, _semanticModel, syntax, type, constantValue, isImplicit); } private IUnaryOperatorExpression CreateBoundUnaryOperatorOperation(BoundUnaryOperator boundUnaryOperator) @@ -841,7 +883,8 @@ private IUnaryOperatorExpression CreateBoundUnaryOperatorOperation(BoundUnaryOpe ITypeSymbol type = boundUnaryOperator.Type; Optional constantValue = ConvertToOptional(boundUnaryOperator.ConstantValue); bool isLifted = boundUnaryOperator.OperatorKind.IsLifted(); - return new LazyUnaryOperatorExpression(unaryOperationKind, operand, isLifted, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundUnaryOperator.WasCompilerGenerated; + return new LazyUnaryOperatorExpression(unaryOperationKind, operand, isLifted, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue, isImplicit); } private IBinaryOperatorExpression CreateBoundBinaryOperatorOperation(BoundBinaryOperator boundBinaryOperator) @@ -855,7 +898,8 @@ private IBinaryOperatorExpression CreateBoundBinaryOperatorOperation(BoundBinary ITypeSymbol type = boundBinaryOperator.Type; Optional constantValue = ConvertToOptional(boundBinaryOperator.ConstantValue); bool isLifted = boundBinaryOperator.OperatorKind.IsLifted(); - return new LazyBinaryOperatorExpression(binaryOperationKind, leftOperand, rightOperand, isLifted, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundBinaryOperator.WasCompilerGenerated; + return new LazyBinaryOperatorExpression(binaryOperationKind, leftOperand, rightOperand, isLifted, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue, isImplicit); } private IConditionalChoiceExpression CreateBoundConditionalOperatorOperation(BoundConditionalOperator boundConditionalOperator) @@ -866,7 +910,8 @@ private IConditionalChoiceExpression CreateBoundConditionalOperatorOperation(Bou SyntaxNode syntax = boundConditionalOperator.Syntax; ITypeSymbol type = boundConditionalOperator.Type; Optional constantValue = ConvertToOptional(boundConditionalOperator.ConstantValue); - return new LazyConditionalChoiceExpression(condition, ifTrueValue, ifFalseValue, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundConditionalOperator.WasCompilerGenerated; + return new LazyConditionalChoiceExpression(condition, ifTrueValue, ifFalseValue, _semanticModel, syntax, type, constantValue, isImplicit); } private INullCoalescingExpression CreateBoundNullCoalescingOperatorOperation(BoundNullCoalescingOperator boundNullCoalescingOperator) @@ -876,7 +921,8 @@ private INullCoalescingExpression CreateBoundNullCoalescingOperatorOperation(Bou SyntaxNode syntax = boundNullCoalescingOperator.Syntax; ITypeSymbol type = boundNullCoalescingOperator.Type; Optional constantValue = ConvertToOptional(boundNullCoalescingOperator.ConstantValue); - return new LazyNullCoalescingExpression(primaryOperand, secondaryOperand, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundNullCoalescingOperator.WasCompilerGenerated; + return new LazyNullCoalescingExpression(primaryOperand, secondaryOperand, _semanticModel, syntax, type, constantValue, isImplicit); } private IAwaitExpression CreateBoundAwaitExpressionOperation(BoundAwaitExpression boundAwaitExpression) @@ -885,7 +931,8 @@ private IAwaitExpression CreateBoundAwaitExpressionOperation(BoundAwaitExpressio SyntaxNode syntax = boundAwaitExpression.Syntax; ITypeSymbol type = boundAwaitExpression.Type; Optional constantValue = ConvertToOptional(boundAwaitExpression.ConstantValue); - return new LazyAwaitExpression(awaitedValue, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundAwaitExpression.WasCompilerGenerated; + return new LazyAwaitExpression(awaitedValue, _semanticModel, syntax, type, constantValue, isImplicit); } private IArrayElementReferenceExpression CreateBoundArrayAccessOperation(BoundArrayAccess boundArrayAccess) @@ -895,7 +942,9 @@ private IArrayElementReferenceExpression CreateBoundArrayAccessOperation(BoundAr SyntaxNode syntax = boundArrayAccess.Syntax; ITypeSymbol type = boundArrayAccess.Type; Optional constantValue = ConvertToOptional(boundArrayAccess.ConstantValue); - return new LazyArrayElementReferenceExpression(arrayReference, indices, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundArrayAccess.WasCompilerGenerated; + + return new LazyArrayElementReferenceExpression(arrayReference, indices, _semanticModel, syntax, type, constantValue, isImplicit); } private IPointerIndirectionReferenceExpression CreateBoundPointerIndirectionOperatorOperation(BoundPointerIndirectionOperator boundPointerIndirectionOperator) @@ -904,7 +953,8 @@ private IPointerIndirectionReferenceExpression CreateBoundPointerIndirectionOper SyntaxNode syntax = boundPointerIndirectionOperator.Syntax; ITypeSymbol type = boundPointerIndirectionOperator.Type; Optional constantValue = ConvertToOptional(boundPointerIndirectionOperator.ConstantValue); - return new LazyPointerIndirectionReferenceExpression(pointer, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundPointerIndirectionOperator.WasCompilerGenerated; + return new LazyPointerIndirectionReferenceExpression(pointer, _semanticModel, syntax, type, constantValue, isImplicit); } private INameOfExpression CreateBoundNameOfOperatorOperation(BoundNameOfOperator boundNameOfOperator) @@ -913,7 +963,8 @@ private INameOfExpression CreateBoundNameOfOperatorOperation(BoundNameOfOperator SyntaxNode syntax = boundNameOfOperator.Syntax; ITypeSymbol type = boundNameOfOperator.Type; Optional constantValue = ConvertToOptional(boundNameOfOperator.ConstantValue); - return new LazyNameOfExpression(argument, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundNameOfOperator.WasCompilerGenerated; + return new LazyNameOfExpression(argument, _semanticModel, syntax, type, constantValue, isImplicit); } private IThrowExpression CreateBoundThrowExpressionOperation(BoundThrowExpression boundThrowExpression) @@ -922,7 +973,8 @@ private IThrowExpression CreateBoundThrowExpressionOperation(BoundThrowExpressio SyntaxNode syntax = boundThrowExpression.Syntax; ITypeSymbol type = boundThrowExpression.Type; Optional constantValue = ConvertToOptional(boundThrowExpression.ConstantValue); - return new LazyThrowExpression(expression, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundThrowExpression.WasCompilerGenerated; + return new LazyThrowExpression(expression, _semanticModel, syntax, type, constantValue, isImplicit); } private IAddressOfExpression CreateBoundAddressOfOperatorOperation(BoundAddressOfOperator boundAddressOfOperator) @@ -931,7 +983,8 @@ private IAddressOfExpression CreateBoundAddressOfOperatorOperation(BoundAddressO SyntaxNode syntax = boundAddressOfOperator.Syntax; ITypeSymbol type = boundAddressOfOperator.Type; Optional constantValue = ConvertToOptional(boundAddressOfOperator.ConstantValue); - return new LazyAddressOfExpression(reference, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundAddressOfOperator.WasCompilerGenerated; + return new LazyAddressOfExpression(reference, _semanticModel, syntax, type, constantValue, isImplicit); } private IInstanceReferenceExpression CreateBoundImplicitReceiverOperation(BoundImplicitReceiver boundImplicitReceiver) @@ -940,7 +993,8 @@ private IInstanceReferenceExpression CreateBoundImplicitReceiverOperation(BoundI SyntaxNode syntax = boundImplicitReceiver.Syntax; ITypeSymbol type = boundImplicitReceiver.Type; Optional constantValue = ConvertToOptional(boundImplicitReceiver.ConstantValue); - return new InstanceReferenceExpression(instanceReferenceKind, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundImplicitReceiver.WasCompilerGenerated; + return new InstanceReferenceExpression(instanceReferenceKind, _semanticModel, syntax, type, constantValue, isImplicit); } private IConditionalAccessExpression CreateBoundConditionalAccessOperation(BoundConditionalAccess boundConditionalAccess) @@ -950,7 +1004,9 @@ private IConditionalAccessExpression CreateBoundConditionalAccessOperation(Bound SyntaxNode syntax = boundConditionalAccess.Syntax; ITypeSymbol type = boundConditionalAccess.Type; Optional constantValue = ConvertToOptional(boundConditionalAccess.ConstantValue); - return new LazyConditionalAccessExpression(conditionalValue, conditionalInstance, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundConditionalAccess.WasCompilerGenerated; + + return new LazyConditionalAccessExpression(conditionalValue, conditionalInstance, _semanticModel, syntax, type, constantValue, isImplicit); } private IConditionalAccessInstanceExpression CreateBoundConditionalReceiverOperation(BoundConditionalReceiver boundConditionalReceiver) @@ -958,7 +1014,8 @@ private IConditionalAccessInstanceExpression CreateBoundConditionalReceiverOpera SyntaxNode syntax = boundConditionalReceiver.Syntax; ITypeSymbol type = boundConditionalReceiver.Type; Optional constantValue = ConvertToOptional(boundConditionalReceiver.ConstantValue); - return new ConditionalAccessInstanceExpression(_semanticModel, syntax, type, constantValue); + bool isImplicit = boundConditionalReceiver.WasCompilerGenerated; + return new ConditionalAccessInstanceExpression(_semanticModel, syntax, type, constantValue, isImplicit); } private IFieldInitializer CreateBoundFieldEqualsValueOperation(BoundFieldEqualsValue boundFieldEqualsValue) @@ -969,7 +1026,8 @@ private IFieldInitializer CreateBoundFieldEqualsValueOperation(BoundFieldEqualsV SyntaxNode syntax = boundFieldEqualsValue.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyFieldInitializer(initializedFields, value, kind, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundFieldEqualsValue.WasCompilerGenerated; + return new LazyFieldInitializer(initializedFields, value, kind, _semanticModel, syntax, type, constantValue, isImplicit); } private IPropertyInitializer CreateBoundPropertyEqualsValueOperation(BoundPropertyEqualsValue boundPropertyEqualsValue) @@ -980,7 +1038,8 @@ private IPropertyInitializer CreateBoundPropertyEqualsValueOperation(BoundProper SyntaxNode syntax = boundPropertyEqualsValue.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyPropertyInitializer(initializedProperty, value, kind, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundPropertyEqualsValue.WasCompilerGenerated; + return new LazyPropertyInitializer(initializedProperty, value, kind, _semanticModel, syntax, type, constantValue, isImplicit); } private IParameterInitializer CreateBoundParameterEqualsValueOperation(BoundParameterEqualsValue boundParameterEqualsValue) @@ -991,7 +1050,8 @@ private IParameterInitializer CreateBoundParameterEqualsValueOperation(BoundPara SyntaxNode syntax = boundParameterEqualsValue.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyParameterInitializer(parameter, value, kind, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundParameterEqualsValue.WasCompilerGenerated; + return new LazyParameterInitializer(parameter, value, kind, _semanticModel, syntax, type, constantValue, isImplicit); } private IBlockStatement CreateBoundBlockOperation(BoundBlock boundBlock) @@ -1003,7 +1063,8 @@ private IBlockStatement CreateBoundBlockOperation(BoundBlock boundBlock) SyntaxNode syntax = boundBlock.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyBlockStatement(statements, locals, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundBlock.WasCompilerGenerated; + return new LazyBlockStatement(statements, locals, _semanticModel, syntax, type, constantValue, isImplicit); } private IBranchStatement CreateBoundContinueStatementOperation(BoundContinueStatement boundContinueStatement) @@ -1013,7 +1074,8 @@ private IBranchStatement CreateBoundContinueStatementOperation(BoundContinueStat SyntaxNode syntax = boundContinueStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new BranchStatement(target, branchKind, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundContinueStatement.WasCompilerGenerated; + return new BranchStatement(target, branchKind, _semanticModel, syntax, type, constantValue, isImplicit); } private IBranchStatement CreateBoundBreakStatementOperation(BoundBreakStatement boundBreakStatement) @@ -1023,7 +1085,8 @@ private IBranchStatement CreateBoundBreakStatementOperation(BoundBreakStatement SyntaxNode syntax = boundBreakStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new BranchStatement(target, branchKind, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundBreakStatement.WasCompilerGenerated; + return new BranchStatement(target, branchKind, _semanticModel, syntax, type, constantValue, isImplicit); } private IReturnStatement CreateBoundYieldBreakStatementOperation(BoundYieldBreakStatement boundYieldBreakStatement) @@ -1032,7 +1095,8 @@ private IReturnStatement CreateBoundYieldBreakStatementOperation(BoundYieldBreak SyntaxNode syntax = boundYieldBreakStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyReturnStatement(OperationKind.YieldBreakStatement, returnedValue, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundYieldBreakStatement.WasCompilerGenerated; + return new LazyReturnStatement(OperationKind.YieldBreakStatement, returnedValue, _semanticModel, syntax, type, constantValue, isImplicit); } private IBranchStatement CreateBoundGotoStatementOperation(BoundGotoStatement boundGotoStatement) @@ -1042,7 +1106,8 @@ private IBranchStatement CreateBoundGotoStatementOperation(BoundGotoStatement bo SyntaxNode syntax = boundGotoStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new BranchStatement(target, branchKind, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundGotoStatement.WasCompilerGenerated; + return new BranchStatement(target, branchKind, _semanticModel, syntax, type, constantValue, isImplicit); } private IEmptyStatement CreateBoundNoOpStatementOperation(BoundNoOpStatement boundNoOpStatement) @@ -1050,7 +1115,8 @@ private IEmptyStatement CreateBoundNoOpStatementOperation(BoundNoOpStatement bou SyntaxNode syntax = boundNoOpStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new EmptyStatement(_semanticModel, syntax, type, constantValue); + bool isImplicit = boundNoOpStatement.WasCompilerGenerated; + return new EmptyStatement(_semanticModel, syntax, type, constantValue, isImplicit); } private IIfStatement CreateBoundIfStatementOperation(BoundIfStatement boundIfStatement) @@ -1061,7 +1127,8 @@ private IIfStatement CreateBoundIfStatementOperation(BoundIfStatement boundIfSta SyntaxNode syntax = boundIfStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyIfStatement(condition, ifTrueStatement, ifFalseStatement, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundIfStatement.WasCompilerGenerated; + return new LazyIfStatement(condition, ifTrueStatement, ifFalseStatement, _semanticModel, syntax, type, constantValue, isImplicit); } private IWhileUntilLoopStatement CreateBoundWhileStatementOperation(BoundWhileStatement boundWhileStatement) @@ -1074,7 +1141,8 @@ private IWhileUntilLoopStatement CreateBoundWhileStatementOperation(BoundWhileSt SyntaxNode syntax = boundWhileStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyWhileUntilLoopStatement(isTopTest, isWhile, condition, loopKind, body, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundWhileStatement.WasCompilerGenerated; + return new LazyWhileUntilLoopStatement(isTopTest, isWhile, condition, loopKind, body, _semanticModel, syntax, type, constantValue, isImplicit); } private IWhileUntilLoopStatement CreateBoundDoStatementOperation(BoundDoStatement boundDoStatement) @@ -1087,7 +1155,8 @@ private IWhileUntilLoopStatement CreateBoundDoStatementOperation(BoundDoStatemen SyntaxNode syntax = boundDoStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyWhileUntilLoopStatement(isTopTest, isWhile, condition, loopKind, body, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundDoStatement.WasCompilerGenerated; + return new LazyWhileUntilLoopStatement(isTopTest, isWhile, condition, loopKind, body, _semanticModel, syntax, type, constantValue, isImplicit); } private IForLoopStatement CreateBoundForStatementOperation(BoundForStatement boundForStatement) @@ -1101,7 +1170,8 @@ private IForLoopStatement CreateBoundForStatementOperation(BoundForStatement bou SyntaxNode syntax = boundForStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyForLoopStatement(before, atLoopBottom, locals, condition, loopKind, body, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundForStatement.WasCompilerGenerated; + return new LazyForLoopStatement(before, atLoopBottom, locals, condition, loopKind, body, _semanticModel, syntax, type, constantValue, isImplicit); } private IForEachLoopStatement CreateBoundForEachStatementOperation(BoundForEachStatement boundForEachStatement) @@ -1115,7 +1185,8 @@ private IForEachLoopStatement CreateBoundForEachStatementOperation(BoundForEachS SyntaxNode syntax = boundForEachStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyForEachLoopStatement(iterationVariable, collection, loopKind, body, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundForEachStatement.WasCompilerGenerated; + return new LazyForEachLoopStatement(iterationVariable, collection, loopKind, body, _semanticModel, syntax, type, constantValue, isImplicit); } private ISwitchStatement CreateBoundSwitchStatementOperation(BoundSwitchStatement boundSwitchStatement) @@ -1125,7 +1196,8 @@ private ISwitchStatement CreateBoundSwitchStatementOperation(BoundSwitchStatemen SyntaxNode syntax = boundSwitchStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazySwitchStatement(value, cases, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundSwitchStatement.WasCompilerGenerated; + return new LazySwitchStatement(value, cases, _semanticModel, syntax, type, constantValue, isImplicit); } private ICaseClause CreateBoundSwitchLabelOperation(BoundSwitchLabel boundSwitchLabel) @@ -1133,16 +1205,17 @@ private ICaseClause CreateBoundSwitchLabelOperation(BoundSwitchLabel boundSwitch SyntaxNode syntax = boundSwitchLabel.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); + bool isImplicit = boundSwitchLabel.WasCompilerGenerated; if (boundSwitchLabel.ExpressionOpt != null) { Lazy value = new Lazy(() => Create(boundSwitchLabel.ExpressionOpt)); BinaryOperationKind equality = GetLabelEqualityKind(boundSwitchLabel); - return new LazySingleValueCaseClause(value, equality, CaseKind.SingleValue, _semanticModel, syntax, type, constantValue); + return new LazySingleValueCaseClause(value, equality, CaseKind.SingleValue, _semanticModel, syntax, type, constantValue, isImplicit); } else { - return new DefaultCaseClause(_semanticModel, syntax, type, constantValue); + return new DefaultCaseClause(_semanticModel, syntax, type, constantValue, isImplicit); } } @@ -1154,7 +1227,8 @@ private ITryStatement CreateBoundTryStatementOperation(BoundTryStatement boundTr SyntaxNode syntax = boundTryStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyTryStatement(body, catches, finallyHandler, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundTryStatement.WasCompilerGenerated; + return new LazyTryStatement(body, catches, finallyHandler, _semanticModel, syntax, type, constantValue, isImplicit); } private ICatchClause CreateBoundCatchBlockOperation(BoundCatchBlock boundCatchBlock) @@ -1166,7 +1240,8 @@ private ICatchClause CreateBoundCatchBlockOperation(BoundCatchBlock boundCatchBl SyntaxNode syntax = boundCatchBlock.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyCatchClause(handler, caughtType, filter, exceptionLocal, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundCatchBlock.WasCompilerGenerated; + return new LazyCatchClause(handler, caughtType, filter, exceptionLocal, _semanticModel, syntax, type, constantValue, isImplicit); } private IFixedStatement CreateBoundFixedStatementOperation(BoundFixedStatement boundFixedStatement) @@ -1176,7 +1251,8 @@ private IFixedStatement CreateBoundFixedStatementOperation(BoundFixedStatement b SyntaxNode syntax = boundFixedStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyFixedStatement(variables, body, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundFixedStatement.WasCompilerGenerated; + return new LazyFixedStatement(variables, body, _semanticModel, syntax, type, constantValue, isImplicit); } private IUsingStatement CreateBoundUsingStatementOperation(BoundUsingStatement boundUsingStatement) @@ -1187,7 +1263,8 @@ private IUsingStatement CreateBoundUsingStatementOperation(BoundUsingStatement b SyntaxNode syntax = boundUsingStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyUsingStatement(body, declaration, value, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundUsingStatement.WasCompilerGenerated; + return new LazyUsingStatement(body, declaration, value, _semanticModel, syntax, type, constantValue, isImplicit); } private IThrowStatement CreateBoundThrowStatementOperation(BoundThrowStatement boundThrowStatement) @@ -1196,7 +1273,8 @@ private IThrowStatement CreateBoundThrowStatementOperation(BoundThrowStatement b SyntaxNode syntax = boundThrowStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyThrowStatement(thrownObject, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundThrowStatement.WasCompilerGenerated; + return new LazyThrowStatement(thrownObject, _semanticModel, syntax, type, constantValue, isImplicit); } private IReturnStatement CreateBoundReturnStatementOperation(BoundReturnStatement boundReturnStatement) @@ -1205,7 +1283,8 @@ private IReturnStatement CreateBoundReturnStatementOperation(BoundReturnStatemen SyntaxNode syntax = boundReturnStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyReturnStatement(OperationKind.ReturnStatement, returnedValue, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundReturnStatement.WasCompilerGenerated; + return new LazyReturnStatement(OperationKind.ReturnStatement, returnedValue, _semanticModel, syntax, type, constantValue, isImplicit); } private IReturnStatement CreateBoundYieldReturnStatementOperation(BoundYieldReturnStatement boundYieldReturnStatement) @@ -1214,7 +1293,8 @@ private IReturnStatement CreateBoundYieldReturnStatementOperation(BoundYieldRetu SyntaxNode syntax = boundYieldReturnStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyReturnStatement(OperationKind.YieldReturnStatement, returnedValue, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundYieldReturnStatement.WasCompilerGenerated; + return new LazyReturnStatement(OperationKind.YieldReturnStatement, returnedValue, _semanticModel, syntax, type, constantValue, isImplicit); } private ILockStatement CreateBoundLockStatementOperation(BoundLockStatement boundLockStatement) @@ -1224,7 +1304,9 @@ private ILockStatement CreateBoundLockStatementOperation(BoundLockStatement boun SyntaxNode syntax = boundLockStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyLockStatement(lockedObject, body, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundLockStatement.WasCompilerGenerated; + + return new LazyLockStatement(lockedObject, body, _semanticModel, syntax, type, constantValue, isImplicit); } private IInvalidStatement CreateBoundBadStatementOperation(BoundBadStatement boundBadStatement) @@ -1233,7 +1315,8 @@ private IInvalidStatement CreateBoundBadStatementOperation(BoundBadStatement bou SyntaxNode syntax = boundBadStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyInvalidStatement(children, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundBadStatement.WasCompilerGenerated; + return new LazyInvalidStatement(children, _semanticModel, syntax, type, constantValue, isImplicit); } private IVariableDeclaration CreateVariableDeclaration(BoundLocalDeclaration boundLocalDeclaration) @@ -1251,7 +1334,8 @@ private IVariableDeclarationStatement CreateBoundLocalDeclarationOperation(Bound SyntaxNode syntax = boundLocalDeclaration.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyVariableDeclarationStatement(declarations, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundLocalDeclaration.WasCompilerGenerated; + return new LazyVariableDeclarationStatement(declarations, _semanticModel, syntax, type, constantValue, isImplicit); } private IVariableDeclarationStatement CreateBoundMultipleLocalDeclarationsOperation(BoundMultipleLocalDeclarations boundMultipleLocalDeclarations) @@ -1261,7 +1345,8 @@ private IVariableDeclarationStatement CreateBoundMultipleLocalDeclarationsOperat SyntaxNode syntax = boundMultipleLocalDeclarations.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyVariableDeclarationStatement(declarations, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundMultipleLocalDeclarations.WasCompilerGenerated; + return new LazyVariableDeclarationStatement(declarations, _semanticModel, syntax, type, constantValue, isImplicit); } private ILabeledStatement CreateBoundLabelStatementOperation(BoundLabelStatement boundLabelStatement) @@ -1271,7 +1356,8 @@ private ILabeledStatement CreateBoundLabelStatementOperation(BoundLabelStatement SyntaxNode syntax = boundLabelStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyLabeledStatement(label, statement, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundLabelStatement.WasCompilerGenerated; + return new LazyLabeledStatement(label, statement, _semanticModel, syntax, type, constantValue, isImplicit); } private ILabeledStatement CreateBoundLabeledStatementOperation(BoundLabeledStatement boundLabeledStatement) @@ -1281,7 +1367,8 @@ private ILabeledStatement CreateBoundLabeledStatementOperation(BoundLabeledState SyntaxNode syntax = boundLabeledStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyLabeledStatement(label, labeledStatement, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundLabeledStatement.WasCompilerGenerated; + return new LazyLabeledStatement(label, labeledStatement, _semanticModel, syntax, type, constantValue, isImplicit); } private IExpressionStatement CreateBoundExpressionStatementOperation(BoundExpressionStatement boundExpressionStatement) @@ -1290,7 +1377,8 @@ private IExpressionStatement CreateBoundExpressionStatementOperation(BoundExpres SyntaxNode syntax = boundExpressionStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyExpressionStatement(expression, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundExpressionStatement.WasCompilerGenerated; + return new LazyExpressionStatement(expression, _semanticModel, syntax, type, constantValue, isImplicit); } private ITupleExpression CreateBoundTupleExpressionOperation(BoundTupleExpression boundTupleExpression) @@ -1299,7 +1387,8 @@ private ITupleExpression CreateBoundTupleExpressionOperation(BoundTupleExpressio SyntaxNode syntax = boundTupleExpression.Syntax; ITypeSymbol type = boundTupleExpression.Type; Optional constantValue = default(Optional); - return new LazyTupleExpression(elements, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundTupleExpression.WasCompilerGenerated; + return new LazyTupleExpression(elements, _semanticModel, syntax, type, constantValue, isImplicit); } private IInterpolatedStringExpression CreateBoundInterpolatedStringExpressionOperation(BoundInterpolatedString boundInterpolatedString) @@ -1309,7 +1398,8 @@ private IInterpolatedStringExpression CreateBoundInterpolatedStringExpressionOpe SyntaxNode syntax = boundInterpolatedString.Syntax; ITypeSymbol type = boundInterpolatedString.Type; Optional constantValue = ConvertToOptional(boundInterpolatedString.ConstantValue); - return new LazyInterpolatedStringExpression(parts, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundInterpolatedString.WasCompilerGenerated; + return new LazyInterpolatedStringExpression(parts, _semanticModel, syntax, type, constantValue, isImplicit); } private IInterpolatedStringContent CreateBoundInterpolatedStringContentOperation(BoundNode boundNode) @@ -1332,7 +1422,8 @@ private IInterpolation CreateBoundInterpolationOperation(BoundStringInsert bound SyntaxNode syntax = boundStringInsert.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyInterpolation(expression, alignment, format, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundStringInsert.WasCompilerGenerated; + return new LazyInterpolation(expression, alignment, format, _semanticModel, syntax, type, constantValue, isImplicit); } private IInterpolatedStringText CreateBoundInterpolatedStringTextOperation(BoundNode boundNode) @@ -1341,7 +1432,8 @@ private IInterpolatedStringText CreateBoundInterpolatedStringTextOperation(Bound SyntaxNode syntax = boundNode.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyInterpolatedStringText(text, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundNode.WasCompilerGenerated; + return new LazyInterpolatedStringText(text, _semanticModel, syntax, type, constantValue, isImplicit); } private IConstantPattern CreateBoundConstantPatternOperation(BoundConstantPattern boundConstantPattern) @@ -1350,7 +1442,8 @@ private IConstantPattern CreateBoundConstantPatternOperation(BoundConstantPatter SyntaxNode syntax = boundConstantPattern.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazyConstantPattern(value, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundConstantPattern.WasCompilerGenerated; + return new LazyConstantPattern(value, _semanticModel, syntax, type, constantValue, isImplicit); } private IDeclarationPattern CreateBoundDeclarationPatternOperation(BoundDeclarationPattern boundDeclarationPattern) @@ -1359,7 +1452,8 @@ private IDeclarationPattern CreateBoundDeclarationPatternOperation(BoundDeclarat SyntaxNode syntax = boundDeclarationPattern.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new DeclarationPattern(variable, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundDeclarationPattern.WasCompilerGenerated; + return new DeclarationPattern(variable, _semanticModel, syntax, type, constantValue, isImplicit); } private ISwitchStatement CreateBoundPatternSwitchStatementOperation(BoundPatternSwitchStatement boundPatternSwitchStatement) @@ -1369,7 +1463,8 @@ private ISwitchStatement CreateBoundPatternSwitchStatementOperation(BoundPattern SyntaxNode syntax = boundPatternSwitchStatement.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); - return new LazySwitchStatement(value, cases, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundPatternSwitchStatement.WasCompilerGenerated; + return new LazySwitchStatement(value, cases, _semanticModel, syntax, type, constantValue, isImplicit); } private ICaseClause CreateBoundPatternSwitchLabelOperation(BoundPatternSwitchLabel boundPatternSwitchLabel) @@ -1377,18 +1472,19 @@ private ICaseClause CreateBoundPatternSwitchLabelOperation(BoundPatternSwitchLab SyntaxNode syntax = boundPatternSwitchLabel.Syntax; ITypeSymbol type = null; Optional constantValue = default(Optional); + bool isImplicit = boundPatternSwitchLabel.WasCompilerGenerated; if (boundPatternSwitchLabel.Pattern.Kind == BoundKind.WildcardPattern) { // Default switch label in pattern switch statement is represented as a default case clause. - return new DefaultCaseClause(_semanticModel, syntax, type, constantValue); + return new DefaultCaseClause(_semanticModel, syntax, type, constantValue, isImplicit); } else { LabelSymbol label = boundPatternSwitchLabel.Label; Lazy pattern = new Lazy(() => (IPattern)Create(boundPatternSwitchLabel.Pattern)); Lazy guardExpression = new Lazy(() => Create(boundPatternSwitchLabel.Guard)); - return new LazyPatternCaseClause(label, pattern, guardExpression, _semanticModel, syntax, type, constantValue); + return new LazyPatternCaseClause(label, pattern, guardExpression, _semanticModel, syntax, type, constantValue, isImplicit); } } @@ -1399,7 +1495,8 @@ private IIsPatternExpression CreateBoundIsPatternExpressionOperation(BoundIsPatt SyntaxNode syntax = boundIsPatternExpression.Syntax; ITypeSymbol type = boundIsPatternExpression.Type; Optional constantValue = ConvertToOptional(boundIsPatternExpression.ConstantValue); - return new LazyIsPatternExpression(expression, pattern, _semanticModel, syntax, type, constantValue); + bool isImplicit = boundIsPatternExpression.WasCompilerGenerated; + return new LazyIsPatternExpression(expression, pattern, _semanticModel, syntax, type, constantValue, isImplicit); } } } diff --git a/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory_Methods.cs b/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory_Methods.cs index b4d36118c6d79e3203d62a0f0673512c6f6a4b3b..3b5140ee35a494a6a62ab3f7e3391bd6c4bcd6ff 100644 --- a/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory_Methods.cs +++ b/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory_Methods.cs @@ -44,7 +44,8 @@ internal IArgument CreateArgumentOperation(ArgumentKind kind, IParameterSymbol p semanticModel: _semanticModel, syntax: value.Syntax, type: value.Type, - constantValue: default); + constantValue: default, + isImplicit: expression.WasCompilerGenerated); } private ImmutableArray DeriveArguments( @@ -116,7 +117,7 @@ private ImmutableArray GetAnonymousObjectCreationInitializers(BoundA SyntaxNode syntax = value.Syntax?.Parent ?? expression.Syntax; ITypeSymbol type = target.Type; Optional constantValue = value.ConstantValue; - var assignment = new SimpleAssignmentExpression(target, value, _semanticModel, syntax, type, constantValue); + var assignment = new SimpleAssignmentExpression(target, value, _semanticModel, syntax, type, constantValue, isImplicit: value.IsImplicit); builder.Add(assignment); } @@ -188,7 +189,7 @@ private ImmutableArray 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, _semanticModel, switchSection.Syntax, type: null, constantValue: default(Optional)); + return (ISwitchCase)new SwitchCase(clauses, body, _semanticModel, switchSection.Syntax, type: null, constantValue: default(Optional), isImplicit: switchSection.WasCompilerGenerated); }); } @@ -199,7 +200,7 @@ private ImmutableArray 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, _semanticModel, switchSection.Syntax, type: null, constantValue: default(Optional)); + return (ISwitchCase)new SwitchCase(clauses, body, _semanticModel, switchSection.Syntax, type: null, constantValue: default(Optional), isImplicit: switchSection.WasCompilerGenerated); }); } diff --git a/src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs b/src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs index 8fa9c5ec5bbc09672aed1dc7c6e8ec06c0e6528e..2149d2b3d9f26d792b4643c3352f5f6a7128b62a 100644 --- a/src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs +++ b/src/Compilers/Core/Portable/Generated/Operations.xml.Generated.cs @@ -12,8 +12,8 @@ namespace Microsoft.CodeAnalysis.Semantics /// internal abstract partial class BaseAddressOfExpression : Operation, IAddressOfExpression { - protected BaseAddressOfExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.AddressOfExpression, semanticModel, syntax, type, constantValue) + protected BaseAddressOfExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.AddressOfExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -43,8 +43,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class AddressOfExpression : BaseAddressOfExpression, IAddressOfExpression { - public AddressOfExpression(IOperation reference, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public AddressOfExpression(IOperation reference, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ReferenceImpl = reference; } @@ -58,7 +58,7 @@ internal sealed partial class LazyAddressOfExpression : BaseAddressOfExpression, { private readonly Lazy _lazyReference; - public LazyAddressOfExpression(Lazy reference, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyAddressOfExpression(Lazy reference, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyReference = reference ?? throw new System.ArgumentNullException(nameof(reference)); } @@ -71,8 +71,8 @@ public LazyAddressOfExpression(Lazy reference, SemanticModel semanti /// internal abstract partial class BaseNameOfExpression : Operation, INameOfExpression { - protected BaseNameOfExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.NameOfExpression, semanticModel, syntax, type, constantValue) + protected BaseNameOfExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.NameOfExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -102,8 +102,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class NameOfExpression : BaseNameOfExpression, INameOfExpression { - public NameOfExpression(IOperation argument, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public NameOfExpression(IOperation argument, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ArgumentImpl = argument; } @@ -117,8 +117,8 @@ internal sealed partial class LazyNameOfExpression : BaseNameOfExpression, IName { private readonly Lazy _lazyArgument; - public LazyNameOfExpression(Lazy argument, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public LazyNameOfExpression(Lazy argument, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyArgument = argument ?? throw new System.ArgumentNullException(nameof(argument)); } @@ -131,8 +131,8 @@ internal sealed partial class LazyNameOfExpression : BaseNameOfExpression, IName /// internal abstract partial class BaseThrowExpression : Operation, IThrowExpression { - protected BaseThrowExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ThrowExpression, semanticModel, syntax, type, constantValue) + protected BaseThrowExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ThrowExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -162,8 +162,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ThrowExpression : BaseThrowExpression, IThrowExpression { - public ThrowExpression(IOperation expression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public ThrowExpression(IOperation expression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ExpressionImpl = expression; } @@ -177,8 +177,8 @@ internal sealed partial class LazyThrowExpression : BaseThrowExpression, IThrowE { private readonly Lazy _lazyExpression; - public LazyThrowExpression(Lazy expression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public LazyThrowExpression(Lazy expression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyExpression = expression ?? throw new System.ArgumentNullException(nameof(expression)); } @@ -191,8 +191,8 @@ internal sealed partial class LazyThrowExpression : BaseThrowExpression, IThrowE /// internal abstract partial class BaseArgument : Operation, IArgument { - protected BaseArgument(ArgumentKind argumentKind, IParameterSymbol parameter, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.Argument, semanticModel, syntax, type, constantValue) + protected BaseArgument(ArgumentKind argumentKind, IParameterSymbol parameter, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.Argument, semanticModel, syntax, type, constantValue, isImplicit) { ArgumentKind = argumentKind; Parameter = parameter; @@ -244,8 +244,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class Argument : BaseArgument, IArgument { - public Argument(ArgumentKind argumentKind, IParameterSymbol parameter, IOperation value, IOperation inConversion, IOperation outConversion, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(argumentKind, parameter, semanticModel, syntax, type, constantValue) + public Argument(ArgumentKind argumentKind, IParameterSymbol parameter, IOperation value, IOperation inConversion, IOperation outConversion, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(argumentKind, parameter, semanticModel, syntax, type, constantValue, isImplicit) { ValueImpl = value; InConversionImpl = inConversion; @@ -266,7 +266,7 @@ internal sealed partial class LazyArgument : BaseArgument, IArgument private readonly Lazy _lazyInConversion; private readonly Lazy _lazyOutConversion; - public LazyArgument(ArgumentKind argumentKind, IParameterSymbol parameter, Lazy value, Lazy inConversion, Lazy outConversion, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(argumentKind, parameter, semanticModel, syntax, type, constantValue) + public LazyArgument(ArgumentKind argumentKind, IParameterSymbol parameter, Lazy value, Lazy inConversion, Lazy outConversion, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(argumentKind, parameter, semanticModel, syntax, type, constantValue, isImplicit) { _lazyValue = value ?? throw new System.ArgumentNullException(nameof(value)); _lazyInConversion = inConversion ?? throw new System.ArgumentNullException(nameof(inConversion)); @@ -285,8 +285,8 @@ public LazyArgument(ArgumentKind argumentKind, IParameterSymbol parameter, Lazy< /// internal abstract partial class BaseArrayCreationExpression : Operation, IArrayCreationExpression { - protected BaseArrayCreationExpression(ITypeSymbol elementType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ArrayCreationExpression, semanticModel, syntax, type, constantValue) + protected BaseArrayCreationExpression(ITypeSymbol elementType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ArrayCreationExpression, semanticModel, syntax, type, constantValue, isImplicit) { ElementType = elementType; } @@ -330,8 +330,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ArrayCreationExpression : BaseArrayCreationExpression, IArrayCreationExpression { - public ArrayCreationExpression(ITypeSymbol elementType, ImmutableArray dimensionSizes, IArrayInitializer initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(elementType, semanticModel, syntax, type, constantValue) + public ArrayCreationExpression(ITypeSymbol elementType, ImmutableArray dimensionSizes, IArrayInitializer initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(elementType, semanticModel, syntax, type, constantValue, isImplicit) { DimensionSizesImpl = dimensionSizes; InitializerImpl = initializer; @@ -349,7 +349,7 @@ internal sealed partial class LazyArrayCreationExpression : BaseArrayCreationExp private readonly Lazy> _lazyDimensionSizes; private readonly Lazy _lazyInitializer; - public LazyArrayCreationExpression(ITypeSymbol elementType, Lazy> dimensionSizes, Lazy initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(elementType, semanticModel, syntax, type, constantValue) + public LazyArrayCreationExpression(ITypeSymbol elementType, Lazy> dimensionSizes, Lazy initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(elementType, semanticModel, syntax, type, constantValue, isImplicit) { _lazyDimensionSizes = dimensionSizes; _lazyInitializer = initializer ?? throw new System.ArgumentNullException(nameof(initializer)); @@ -365,8 +365,8 @@ public LazyArrayCreationExpression(ITypeSymbol elementType, Lazy internal abstract partial class BaseArrayElementReferenceExpression : Operation, IArrayElementReferenceExpression { - protected BaseArrayElementReferenceExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ArrayElementReferenceExpression, semanticModel, syntax, type, constantValue) + protected BaseArrayElementReferenceExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ArrayElementReferenceExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -406,8 +406,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ArrayElementReferenceExpression : BaseArrayElementReferenceExpression, IArrayElementReferenceExpression { - public ArrayElementReferenceExpression(IOperation arrayReference, ImmutableArray indices, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public ArrayElementReferenceExpression(IOperation arrayReference, ImmutableArray indices, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ArrayReferenceImpl = arrayReference; IndicesImpl = indices; @@ -425,7 +425,7 @@ internal sealed partial class LazyArrayElementReferenceExpression : BaseArrayEle private readonly Lazy _lazyArrayReference; private readonly Lazy> _lazyIndices; - public LazyArrayElementReferenceExpression(Lazy arrayReference, Lazy> indices, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyArrayElementReferenceExpression(Lazy arrayReference, Lazy> indices, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyArrayReference = arrayReference ?? throw new System.ArgumentNullException(nameof(arrayReference)); _lazyIndices = indices; @@ -441,8 +441,8 @@ public LazyArrayElementReferenceExpression(Lazy arrayReference, Lazy /// internal abstract partial class BaseArrayInitializer : Operation, IArrayInitializer { - protected BaseArrayInitializer(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ArrayInitializer, semanticModel, syntax, type, constantValue) + protected BaseArrayInitializer(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ArrayInitializer, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -476,8 +476,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ArrayInitializer : BaseArrayInitializer, IArrayInitializer { - public ArrayInitializer(ImmutableArray elementValues, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public ArrayInitializer(ImmutableArray elementValues, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ElementValuesImpl = elementValues; } @@ -492,7 +492,7 @@ internal sealed partial class LazyArrayInitializer : BaseArrayInitializer, IArra { private readonly Lazy> _lazyElementValues; - public LazyArrayInitializer(Lazy> elementValues, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyArrayInitializer(Lazy> elementValues, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyElementValues = elementValues; } @@ -505,8 +505,8 @@ public LazyArrayInitializer(Lazy> elementValues, Sema /// internal abstract partial class AssignmentExpression : Operation, IAssignmentExpression { - protected AssignmentExpression(OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(kind, semanticModel, syntax, type, constantValue) + protected AssignmentExpression(OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(kind, semanticModel, syntax, type, constantValue, isImplicit) { } protected abstract IOperation TargetImpl { get; } @@ -526,8 +526,8 @@ internal abstract partial class AssignmentExpression : Operation, IAssignmentExp /// internal abstract partial class BaseSimpleAssignmentExpression : AssignmentExpression, ISimpleAssignmentExpression { - public BaseSimpleAssignmentExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.SimpleAssignmentExpression, semanticModel, syntax, type, constantValue) + public BaseSimpleAssignmentExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.SimpleAssignmentExpression, semanticModel, syntax, type, constantValue, isImplicit) { } public override IEnumerable Children @@ -553,8 +553,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class SimpleAssignmentExpression : BaseSimpleAssignmentExpression, ISimpleAssignmentExpression { - public SimpleAssignmentExpression(IOperation target, IOperation value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public SimpleAssignmentExpression(IOperation target, IOperation value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { TargetImpl = target; ValueImpl = value; @@ -571,8 +571,8 @@ internal sealed partial class LazySimpleAssignmentExpression : BaseSimpleAssignm private readonly Lazy _lazyTarget; private readonly Lazy _lazyValue; - public LazySimpleAssignmentExpression(Lazy target, Lazy value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public LazySimpleAssignmentExpression(Lazy target, Lazy value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyTarget = target ?? throw new System.ArgumentNullException(nameof(target)); _lazyValue = value ?? throw new System.ArgumentNullException(nameof(value)); @@ -586,8 +586,8 @@ internal sealed partial class LazySimpleAssignmentExpression : BaseSimpleAssignm /// internal abstract partial class BaseAwaitExpression : Operation, IAwaitExpression { - protected BaseAwaitExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.AwaitExpression, semanticModel, syntax, type, constantValue) + protected BaseAwaitExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.AwaitExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -618,8 +618,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class AwaitExpression : BaseAwaitExpression, IAwaitExpression { - public AwaitExpression(IOperation awaitedValue, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public AwaitExpression(IOperation awaitedValue, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { AwaitedValueImpl = awaitedValue; } @@ -634,7 +634,7 @@ internal sealed partial class LazyAwaitExpression : BaseAwaitExpression, IAwaitE { private readonly Lazy _lazyAwaitedValue; - public LazyAwaitExpression(Lazy awaitedValue, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyAwaitExpression(Lazy awaitedValue, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyAwaitedValue = awaitedValue ?? throw new System.ArgumentNullException(nameof(awaitedValue)); } @@ -647,8 +647,8 @@ public LazyAwaitExpression(Lazy awaitedValue, SemanticModel semantic /// internal abstract partial class BaseBinaryOperatorExpression : Operation, IHasOperatorMethodExpression, IBinaryOperatorExpression { - protected BaseBinaryOperatorExpression(BinaryOperationKind binaryOperationKind, bool isLifted, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.BinaryOperatorExpression, semanticModel, syntax, type, constantValue) + protected BaseBinaryOperatorExpression(BinaryOperationKind binaryOperationKind, bool isLifted, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.BinaryOperatorExpression, semanticModel, syntax, type, constantValue, isImplicit) { BinaryOperationKind = binaryOperationKind; UsesOperatorMethod = usesOperatorMethod; @@ -703,8 +703,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class BinaryOperatorExpression : BaseBinaryOperatorExpression, IHasOperatorMethodExpression, IBinaryOperatorExpression { - public BinaryOperatorExpression(BinaryOperationKind binaryOperationKind, IOperation leftOperand, IOperation rightOperand, bool isLifted, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(binaryOperationKind, isLifted, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue) + public BinaryOperatorExpression(BinaryOperationKind binaryOperationKind, IOperation leftOperand, IOperation rightOperand, bool isLifted, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(binaryOperationKind, isLifted, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue, isImplicit) { LeftOperandImpl = leftOperand; RightOperandImpl = rightOperand; @@ -722,8 +722,8 @@ internal sealed partial class LazyBinaryOperatorExpression : BaseBinaryOperatorE private readonly Lazy _lazyLeftOperand; private readonly Lazy _lazyRightOperand; - public LazyBinaryOperatorExpression(BinaryOperationKind binaryOperationKind, Lazy leftOperand, Lazy rightOperand, bool isLifted, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(binaryOperationKind, isLifted, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue) + public LazyBinaryOperatorExpression(BinaryOperationKind binaryOperationKind, Lazy leftOperand, Lazy rightOperand, bool isLifted, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(binaryOperationKind, isLifted, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue, isImplicit) { _lazyLeftOperand = leftOperand ?? throw new System.ArgumentNullException(nameof(leftOperand)); _lazyRightOperand = rightOperand ?? throw new System.ArgumentNullException(nameof(rightOperand)); @@ -739,8 +739,8 @@ internal sealed partial class LazyBinaryOperatorExpression : BaseBinaryOperatorE /// internal abstract partial class BaseBlockStatement : Operation, IBlockStatement { - protected BaseBlockStatement(ImmutableArray locals, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.BlockStatement, semanticModel, syntax, type, constantValue) + protected BaseBlockStatement(ImmutableArray locals, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.BlockStatement, semanticModel, syntax, type, constantValue, isImplicit) { Locals = locals; } @@ -779,8 +779,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class BlockStatement : BaseBlockStatement, IBlockStatement { - public BlockStatement(ImmutableArray statements, ImmutableArray locals, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(locals, semanticModel, syntax, type, constantValue) + public BlockStatement(ImmutableArray statements, ImmutableArray locals, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(locals, semanticModel, syntax, type, constantValue, isImplicit) { StatementsImpl = statements; } @@ -795,7 +795,7 @@ internal sealed partial class LazyBlockStatement : BaseBlockStatement, IBlockSta { private readonly Lazy> _lazyStatements; - public LazyBlockStatement(Lazy> statements, ImmutableArray locals, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(locals, semanticModel, syntax, type, constantValue) + public LazyBlockStatement(Lazy> statements, ImmutableArray locals, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(locals, semanticModel, syntax, type, constantValue, isImplicit) { _lazyStatements = statements; } @@ -808,8 +808,8 @@ public LazyBlockStatement(Lazy> statements, Immutable /// internal sealed partial class BranchStatement : Operation, IBranchStatement { - public BranchStatement(ILabelSymbol target, BranchKind branchKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.BranchStatement, semanticModel, syntax, type, constantValue) + public BranchStatement(ILabelSymbol target, BranchKind branchKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.BranchStatement, semanticModel, syntax, type, constantValue, isImplicit) { Target = target; BranchKind = branchKind; @@ -844,8 +844,8 @@ public override void Accept(OperationVisitor visitor) /// internal abstract partial class CaseClause : Operation, ICaseClause { - protected CaseClause(CaseKind caseKind, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(kind, semanticModel, syntax, type, constantValue) + protected CaseClause(CaseKind caseKind, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(kind, semanticModel, syntax, type, constantValue, isImplicit) { CaseKind = caseKind; } @@ -860,8 +860,8 @@ internal abstract partial class CaseClause : Operation, ICaseClause /// internal abstract partial class BaseCatchClause : Operation, ICatchClause { - protected BaseCatchClause(ITypeSymbol caughtType, ILocalSymbol exceptionLocal, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.CatchClause, semanticModel, syntax, type, constantValue) + protected BaseCatchClause(ITypeSymbol caughtType, ILocalSymbol exceptionLocal, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.CatchClause, semanticModel, syntax, type, constantValue, isImplicit) { CaughtType = caughtType; ExceptionLocal = exceptionLocal; @@ -908,8 +908,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class CatchClause : BaseCatchClause, ICatchClause { - public CatchClause(IBlockStatement handler, ITypeSymbol caughtType, IOperation filter, ILocalSymbol exceptionLocal, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(caughtType, exceptionLocal, semanticModel, syntax, type, constantValue) + public CatchClause(IBlockStatement handler, ITypeSymbol caughtType, IOperation filter, ILocalSymbol exceptionLocal, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(caughtType, exceptionLocal, semanticModel, syntax, type, constantValue, isImplicit) { HandlerImpl = handler; FilterImpl = filter; @@ -927,7 +927,7 @@ internal sealed partial class LazyCatchClause : BaseCatchClause, ICatchClause private readonly Lazy _lazyHandler; private readonly Lazy _lazyFilter; - public LazyCatchClause(Lazy handler, ITypeSymbol caughtType, Lazy filter, ILocalSymbol exceptionLocal, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(caughtType, exceptionLocal, semanticModel, syntax, type, constantValue) + public LazyCatchClause(Lazy handler, ITypeSymbol caughtType, Lazy filter, ILocalSymbol exceptionLocal, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(caughtType, exceptionLocal, semanticModel, syntax, type, constantValue, isImplicit) { _lazyHandler = handler ?? throw new System.ArgumentNullException(nameof(handler)); _lazyFilter = filter ?? throw new System.ArgumentNullException(nameof(filter)); @@ -943,8 +943,8 @@ public LazyCatchClause(Lazy handler, ITypeSymbol caughtType, La /// internal abstract partial class BaseCompoundAssignmentExpression : AssignmentExpression, IHasOperatorMethodExpression, ICompoundAssignmentExpression { - protected BaseCompoundAssignmentExpression(BinaryOperationKind binaryOperationKind, bool isLifted, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.CompoundAssignmentExpression, semanticModel, syntax, type, constantValue) + protected BaseCompoundAssignmentExpression(BinaryOperationKind binaryOperationKind, bool isLifted, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.CompoundAssignmentExpression, semanticModel, syntax, type, constantValue, isImplicit) { BinaryOperationKind = binaryOperationKind; IsLifted = isLifted; @@ -991,8 +991,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class CompoundAssignmentExpression : BaseCompoundAssignmentExpression, IHasOperatorMethodExpression, ICompoundAssignmentExpression { - public CompoundAssignmentExpression(BinaryOperationKind binaryOperationKind, bool isLifted, IOperation target, IOperation value, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(binaryOperationKind, isLifted, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue) + public CompoundAssignmentExpression(BinaryOperationKind binaryOperationKind, bool isLifted, IOperation target, IOperation value, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(binaryOperationKind, isLifted, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue, isImplicit) { TargetImpl = target; ValueImpl = value; @@ -1009,8 +1009,8 @@ internal sealed partial class LazyCompoundAssignmentExpression : BaseCompoundAss private readonly Lazy _lazyTarget; private readonly Lazy _lazyValue; - public LazyCompoundAssignmentExpression(BinaryOperationKind binaryOperationKind, bool isLifted, Lazy target, Lazy value, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(binaryOperationKind, isLifted, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue) + public LazyCompoundAssignmentExpression(BinaryOperationKind binaryOperationKind, bool isLifted, Lazy target, Lazy value, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(binaryOperationKind, isLifted, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue, isImplicit) { _lazyTarget = target ?? throw new System.ArgumentNullException(nameof(target)); _lazyValue = value ?? throw new System.ArgumentNullException(nameof(value)); @@ -1024,8 +1024,8 @@ internal sealed partial class LazyCompoundAssignmentExpression : BaseCompoundAss /// internal abstract partial class BaseConditionalAccessExpression : Operation, IConditionalAccessExpression { - protected BaseConditionalAccessExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ConditionalAccessExpression, semanticModel, syntax, type, constantValue) + protected BaseConditionalAccessExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ConditionalAccessExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -1062,8 +1062,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ConditionalAccessExpression : BaseConditionalAccessExpression, IConditionalAccessExpression { - public ConditionalAccessExpression(IOperation conditionalValue, IOperation conditionalInstance, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public ConditionalAccessExpression(IOperation conditionalValue, IOperation conditionalInstance, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ConditionalValueImpl = conditionalValue; ConditionalInstanceImpl = conditionalInstance; @@ -1081,7 +1081,7 @@ internal sealed partial class LazyConditionalAccessExpression : BaseConditionalA private readonly Lazy _lazyConditionalValue; private readonly Lazy _lazyConditionalInstance; - public LazyConditionalAccessExpression(Lazy conditionalValue, Lazy conditionalInstance, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyConditionalAccessExpression(Lazy conditionalValue, Lazy conditionalInstance, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyConditionalValue = conditionalValue ?? throw new System.ArgumentNullException(nameof(conditionalValue)); _lazyConditionalInstance = conditionalInstance ?? throw new System.ArgumentNullException(nameof(conditionalInstance)); @@ -1097,8 +1097,8 @@ public LazyConditionalAccessExpression(Lazy conditionalValue, Lazy internal sealed partial class ConditionalAccessInstanceExpression : Operation, IConditionalAccessInstanceExpression { - public ConditionalAccessInstanceExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ConditionalAccessInstanceExpression, semanticModel, syntax, type, constantValue) + public ConditionalAccessInstanceExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ConditionalAccessInstanceExpression, semanticModel, syntax, type, constantValue, isImplicit) { } public override IEnumerable Children @@ -1123,8 +1123,8 @@ public override void Accept(OperationVisitor visitor) /// internal abstract partial class BaseConditionalChoiceExpression : Operation, IConditionalChoiceExpression { - protected BaseConditionalChoiceExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ConditionalChoiceExpression, semanticModel, syntax, type, constantValue) + protected BaseConditionalChoiceExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ConditionalChoiceExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -1167,8 +1167,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ConditionalChoiceExpression : BaseConditionalChoiceExpression, IConditionalChoiceExpression { - public ConditionalChoiceExpression(IOperation condition, IOperation ifTrueValue, IOperation ifFalseValue, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public ConditionalChoiceExpression(IOperation condition, IOperation ifTrueValue, IOperation ifFalseValue, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ConditionImpl = condition; IfTrueValueImpl = ifTrueValue; @@ -1189,7 +1189,7 @@ internal sealed partial class LazyConditionalChoiceExpression : BaseConditionalC private readonly Lazy _lazyIfTrueValue; private readonly Lazy _lazyIfFalseValue; - public LazyConditionalChoiceExpression(Lazy condition, Lazy ifTrueValue, Lazy ifFalseValue, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyConditionalChoiceExpression(Lazy condition, Lazy ifTrueValue, Lazy ifFalseValue, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyCondition = condition ?? throw new System.ArgumentNullException(nameof(condition)); _lazyIfTrueValue = ifTrueValue ?? throw new System.ArgumentNullException(nameof(ifTrueValue)); @@ -1208,8 +1208,8 @@ public LazyConditionalChoiceExpression(Lazy condition, Lazy internal abstract partial class BaseConversionExpression : Operation, IHasOperatorMethodExpression, IConversionExpression { - protected BaseConversionExpression(bool isExplicitInCode, bool isTryCast, bool isChecked, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ConversionExpression, semanticModel, syntax, type, constantValue) + protected BaseConversionExpression(bool isExplicitInCode, bool isTryCast, bool isChecked, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ConversionExpression, semanticModel, syntax, type, constantValue, isImplicit) { IsExplicitInCode = isExplicitInCode; IsTryCast = isTryCast; @@ -1250,8 +1250,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class DefaultValueExpression : Operation, IDefaultValueExpression { - public DefaultValueExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.DefaultValueExpression, semanticModel, syntax, type, constantValue) + public DefaultValueExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.DefaultValueExpression, semanticModel, syntax, type, constantValue, isImplicit) { } public override IEnumerable Children @@ -1276,8 +1276,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class EmptyStatement : Operation, IEmptyStatement { - public EmptyStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.EmptyStatement, semanticModel, syntax, type, constantValue) + public EmptyStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.EmptyStatement, semanticModel, syntax, type, constantValue, isImplicit) { } public override IEnumerable Children @@ -1302,8 +1302,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class EndStatement : Operation, IEndStatement { - public EndStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.EndStatement, semanticModel, syntax, type, constantValue) + public EndStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.EndStatement, semanticModel, syntax, type, constantValue, isImplicit) { } public override IEnumerable Children @@ -1328,8 +1328,8 @@ public override void Accept(OperationVisitor visitor) /// internal abstract partial class BaseEventAssignmentExpression : Operation, IEventAssignmentExpression { - protected BaseEventAssignmentExpression(bool adds, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.EventAssignmentExpression, semanticModel, syntax, type, constantValue) + protected BaseEventAssignmentExpression(bool adds, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.EventAssignmentExpression, semanticModel, syntax, type, constantValue, isImplicit) { Adds = adds; } @@ -1381,8 +1381,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class EventAssignmentExpression : BaseEventAssignmentExpression, IEventAssignmentExpression { - public EventAssignmentExpression(IEventReferenceExpression eventReference, IOperation handlerValue, bool adds, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(adds, semanticModel, syntax, type, constantValue) + public EventAssignmentExpression(IEventReferenceExpression eventReference, IOperation handlerValue, bool adds, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(adds, semanticModel, syntax, type, constantValue, isImplicit) { EventReferenceImpl = eventReference; HandlerValueImpl = handlerValue; @@ -1399,14 +1399,14 @@ internal sealed partial class LazyEventAssignmentExpression : BaseEventAssignmen { private readonly Lazy _lazyEventReference; private readonly Lazy _lazyHandlerValue; - - public LazyEventAssignmentExpression(Lazy eventReference, Lazy handlerValue, bool adds, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(adds, semanticModel, syntax, type, constantValue) + + public LazyEventAssignmentExpression(Lazy eventReference, Lazy handlerValue, bool adds, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(adds, semanticModel, syntax, type, constantValue, isImplicit) { _lazyEventReference = eventReference ?? throw new System.ArgumentNullException(nameof(eventReference)); _lazyHandlerValue = handlerValue ?? throw new System.ArgumentNullException(nameof(handlerValue)); } - + protected override IEventReferenceExpression EventReferenceImpl => _lazyEventReference.Value; protected override IOperation HandlerValueImpl => _lazyHandlerValue.Value; @@ -1417,8 +1417,8 @@ public LazyEventAssignmentExpression(Lazy eventRefere /// internal abstract partial class BaseEventReferenceExpression : MemberReferenceExpression, IEventReferenceExpression { - public BaseEventReferenceExpression(IEventSymbol @event, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(member, OperationKind.EventReferenceExpression, semanticModel, syntax, type, constantValue) + public BaseEventReferenceExpression(IEventSymbol @event, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(member, OperationKind.EventReferenceExpression, semanticModel, syntax, type, constantValue, isImplicit) { Event = @event; } @@ -1449,8 +1449,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class EventReferenceExpression : BaseEventReferenceExpression, IEventReferenceExpression { - public EventReferenceExpression(IEventSymbol @event, IOperation instance, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(@event, member, semanticModel, syntax, type, constantValue) + public EventReferenceExpression(IEventSymbol @event, IOperation instance, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(@event, member, semanticModel, syntax, type, constantValue, isImplicit) { InstanceImpl = instance; } @@ -1464,8 +1464,8 @@ internal sealed partial class LazyEventReferenceExpression : BaseEventReferenceE { private readonly Lazy _lazyInstance; - public LazyEventReferenceExpression(IEventSymbol @event, Lazy instance, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(@event, member, semanticModel, syntax, type, constantValue) + public LazyEventReferenceExpression(IEventSymbol @event, Lazy instance, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(@event, member, semanticModel, syntax, type, constantValue, isImplicit) { _lazyInstance = instance ?? throw new System.ArgumentNullException(nameof(instance)); } @@ -1477,8 +1477,8 @@ internal sealed partial class LazyEventReferenceExpression : BaseEventReferenceE /// internal abstract partial class BaseExpressionStatement : Operation, IExpressionStatement { - protected BaseExpressionStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ExpressionStatement, semanticModel, syntax, type, constantValue) + protected BaseExpressionStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ExpressionStatement, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -1509,8 +1509,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ExpressionStatement : BaseExpressionStatement, IExpressionStatement { - public ExpressionStatement(IOperation expression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public ExpressionStatement(IOperation expression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ExpressionImpl = expression; } @@ -1525,7 +1525,7 @@ internal sealed partial class LazyExpressionStatement : BaseExpressionStatement, { private readonly Lazy _lazyExpression; - public LazyExpressionStatement(Lazy expression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyExpressionStatement(Lazy expression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyExpression = expression ?? throw new System.ArgumentNullException(nameof(expression)); } @@ -1538,8 +1538,8 @@ public LazyExpressionStatement(Lazy expression, SemanticModel semant /// internal abstract partial class BaseFieldInitializer : SymbolInitializer, IFieldInitializer { - public BaseFieldInitializer(ImmutableArray initializedFields, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(kind, semanticModel, syntax, type, constantValue) + public BaseFieldInitializer(ImmutableArray initializedFields, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(kind, semanticModel, syntax, type, constantValue, isImplicit) { InitializedFields = initializedFields; } @@ -1570,8 +1570,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class FieldInitializer : BaseFieldInitializer, IFieldInitializer { - public FieldInitializer(ImmutableArray initializedFields, IOperation value, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(initializedFields, kind, semanticModel, syntax, type, constantValue) + public FieldInitializer(ImmutableArray initializedFields, IOperation value, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(initializedFields, kind, semanticModel, syntax, type, constantValue, isImplicit) { ValueImpl = value; } @@ -1585,8 +1585,8 @@ internal sealed partial class LazyFieldInitializer : BaseFieldInitializer, IFiel { private readonly Lazy _lazyValue; - public LazyFieldInitializer(ImmutableArray initializedFields, Lazy value, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(initializedFields, kind, semanticModel, syntax, type, constantValue) + public LazyFieldInitializer(ImmutableArray initializedFields, Lazy value, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(initializedFields, kind, semanticModel, syntax, type, constantValue, isImplicit) { _lazyValue = value ?? throw new System.ArgumentNullException(nameof(value)); } @@ -1598,8 +1598,8 @@ internal sealed partial class LazyFieldInitializer : BaseFieldInitializer, IFiel /// internal abstract partial class BaseFieldReferenceExpression : MemberReferenceExpression, IFieldReferenceExpression { - public BaseFieldReferenceExpression(IFieldSymbol field, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(member, OperationKind.FieldReferenceExpression, semanticModel, syntax, type, constantValue) + public BaseFieldReferenceExpression(IFieldSymbol field, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(member, OperationKind.FieldReferenceExpression, semanticModel, syntax, type, constantValue, isImplicit) { Field = field; } @@ -1630,8 +1630,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class FieldReferenceExpression : BaseFieldReferenceExpression, IFieldReferenceExpression { - public FieldReferenceExpression(IFieldSymbol field, IOperation instance, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(field, member, semanticModel, syntax, type, constantValue) + public FieldReferenceExpression(IFieldSymbol field, IOperation instance, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(field, member, semanticModel, syntax, type, constantValue, isImplicit) { InstanceImpl = instance; } @@ -1645,8 +1645,8 @@ internal sealed partial class LazyFieldReferenceExpression : BaseFieldReferenceE { private readonly Lazy _lazyInstance; - public LazyFieldReferenceExpression(IFieldSymbol field, Lazy instance, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(field, member, semanticModel, syntax, type, constantValue) + public LazyFieldReferenceExpression(IFieldSymbol field, Lazy instance, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(field, member, semanticModel, syntax, type, constantValue, isImplicit) { _lazyInstance = instance ?? throw new System.ArgumentNullException(nameof(instance)); } @@ -1658,8 +1658,8 @@ internal sealed partial class LazyFieldReferenceExpression : BaseFieldReferenceE /// internal abstract partial class BaseFixedStatement : Operation, IFixedStatement { - protected BaseFixedStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.FixedStatement, semanticModel, syntax, type, constantValue) + protected BaseFixedStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.FixedStatement, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -1696,8 +1696,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class FixedStatement : BaseFixedStatement, IFixedStatement { - public FixedStatement(IVariableDeclarationStatement variables, IOperation body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public FixedStatement(IVariableDeclarationStatement variables, IOperation body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { VariablesImpl = variables; BodyImpl = body; @@ -1715,7 +1715,7 @@ internal sealed partial class LazyFixedStatement : BaseFixedStatement, IFixedSta private readonly Lazy _lazyVariables; private readonly Lazy _lazyBody; - public LazyFixedStatement(Lazy variables, Lazy body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyFixedStatement(Lazy variables, Lazy body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyVariables = variables ?? throw new System.ArgumentNullException(nameof(variables)); _lazyBody = body ?? throw new System.ArgumentNullException(nameof(body)); @@ -1731,8 +1731,8 @@ public LazyFixedStatement(Lazy variables, Lazy internal abstract partial class BaseForEachLoopStatement : LoopStatement, IForEachLoopStatement { - public BaseForEachLoopStatement(ILocalSymbol iterationVariable, LoopKind loopKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(loopKind, OperationKind.LoopStatement, semanticModel, syntax, type, constantValue) + public BaseForEachLoopStatement(ILocalSymbol iterationVariable, LoopKind loopKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(loopKind, OperationKind.LoopStatement, semanticModel, syntax, type, constantValue, isImplicit) { IterationVariable = iterationVariable; } @@ -1769,8 +1769,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ForEachLoopStatement : BaseForEachLoopStatement, IForEachLoopStatement { - public ForEachLoopStatement(ILocalSymbol iterationVariable, IOperation collection, LoopKind loopKind, IOperation body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(iterationVariable, loopKind, semanticModel, syntax, type, constantValue) + public ForEachLoopStatement(ILocalSymbol iterationVariable, IOperation collection, LoopKind loopKind, IOperation body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(iterationVariable, loopKind, semanticModel, syntax, type, constantValue, isImplicit) { CollectionImpl = collection; BodyImpl = body; @@ -1788,8 +1788,8 @@ internal sealed partial class LazyForEachLoopStatement : BaseForEachLoopStatemen private readonly Lazy _lazyCollection; private readonly Lazy _lazyBody; - public LazyForEachLoopStatement(ILocalSymbol iterationVariable, Lazy collection, LoopKind loopKind, Lazy body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(iterationVariable, loopKind, semanticModel, syntax, type, constantValue) + public LazyForEachLoopStatement(ILocalSymbol iterationVariable, Lazy collection, LoopKind loopKind, Lazy body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(iterationVariable, loopKind, semanticModel, syntax, type, constantValue, isImplicit) { _lazyCollection = collection ?? throw new System.ArgumentNullException(nameof(collection)); _lazyBody = body ?? throw new System.ArgumentNullException(nameof(body)); @@ -1804,8 +1804,8 @@ internal sealed partial class LazyForEachLoopStatement : BaseForEachLoopStatemen /// internal abstract partial class BaseForLoopStatement : ForWhileUntilLoopStatement, IForLoopStatement { - public BaseForLoopStatement(ImmutableArray locals, LoopKind loopKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(loopKind, OperationKind.LoopStatement, semanticModel, syntax, type, constantValue) + public BaseForLoopStatement(ImmutableArray locals, LoopKind loopKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(loopKind, OperationKind.LoopStatement, semanticModel, syntax, type, constantValue, isImplicit) { Locals = locals; } @@ -1856,8 +1856,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ForLoopStatement : BaseForLoopStatement, IForLoopStatement { - public ForLoopStatement(ImmutableArray before, ImmutableArray atLoopBottom, ImmutableArray locals, IOperation condition, LoopKind loopKind, IOperation body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(locals, loopKind, semanticModel, syntax, type, constantValue) + public ForLoopStatement(ImmutableArray before, ImmutableArray atLoopBottom, ImmutableArray locals, IOperation condition, LoopKind loopKind, IOperation body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(locals, loopKind, semanticModel, syntax, type, constantValue, isImplicit) { BeforeImpl = before; AtLoopBottomImpl = atLoopBottom; @@ -1881,8 +1881,8 @@ internal sealed partial class LazyForLoopStatement : BaseForLoopStatement, IForL private readonly Lazy _lazyCondition; private readonly Lazy _lazyBody; - public LazyForLoopStatement(Lazy> before, Lazy> atLoopBottom, ImmutableArray locals, Lazy condition, LoopKind loopKind, Lazy body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(locals, loopKind, semanticModel, syntax, type, constantValue) + public LazyForLoopStatement(Lazy> before, Lazy> atLoopBottom, ImmutableArray locals, Lazy condition, LoopKind loopKind, Lazy body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(locals, loopKind, semanticModel, syntax, type, constantValue, isImplicit) { _lazyBefore = before; _lazyAtLoopBottom = atLoopBottom; @@ -1904,8 +1904,8 @@ internal sealed partial class LazyForLoopStatement : BaseForLoopStatement, IForL /// internal abstract partial class ForWhileUntilLoopStatement : LoopStatement, IForWhileUntilLoopStatement { - protected ForWhileUntilLoopStatement(LoopKind loopKind, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(loopKind, kind, semanticModel, syntax, type, constantValue) + protected ForWhileUntilLoopStatement(LoopKind loopKind, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(loopKind, kind, semanticModel, syntax, type, constantValue, isImplicit) { } protected abstract IOperation ConditionImpl { get; } @@ -1920,8 +1920,8 @@ internal abstract partial class ForWhileUntilLoopStatement : LoopStatement, IFor /// internal abstract partial class BaseIfStatement : Operation, IIfStatement { - protected BaseIfStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.IfStatement, semanticModel, syntax, type, constantValue) + protected BaseIfStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.IfStatement, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -1964,8 +1964,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class IfStatement : BaseIfStatement, IIfStatement { - public IfStatement(IOperation condition, IOperation ifTrueStatement, IOperation ifFalseStatement, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public IfStatement(IOperation condition, IOperation ifTrueStatement, IOperation ifFalseStatement, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ConditionImpl = condition; IfTrueStatementImpl = ifTrueStatement; @@ -1986,7 +1986,7 @@ internal sealed partial class LazyIfStatement : BaseIfStatement, IIfStatement private readonly Lazy _lazyIfTrueStatement; private readonly Lazy _lazyIfFalseStatement; - public LazyIfStatement(Lazy condition, Lazy ifTrueStatement, Lazy ifFalseStatement, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyIfStatement(Lazy condition, Lazy ifTrueStatement, Lazy ifFalseStatement, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyCondition = condition ?? throw new System.ArgumentNullException(nameof(condition)); _lazyIfTrueStatement = ifTrueStatement ?? throw new System.ArgumentNullException(nameof(ifTrueStatement)); @@ -2005,8 +2005,8 @@ public LazyIfStatement(Lazy condition, Lazy ifTrueStatem /// internal abstract partial class BaseIncrementExpression : Operation, IIncrementExpression { - public BaseIncrementExpression(UnaryOperationKind incrementOperationKind, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.IncrementExpression, semanticModel, syntax, type, constantValue) + public BaseIncrementExpression(UnaryOperationKind incrementOperationKind, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.IncrementExpression, semanticModel, syntax, type, constantValue, isImplicit) { IncrementOperationKind = incrementOperationKind; UsesOperatorMethod = usesOperatorMethod; @@ -2052,8 +2052,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class IncrementExpression : BaseIncrementExpression, IIncrementExpression { - public IncrementExpression(UnaryOperationKind incrementOperationKind, IOperation target, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(incrementOperationKind, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue) + public IncrementExpression(UnaryOperationKind incrementOperationKind, IOperation target, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(incrementOperationKind, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue, isImplicit) { TargetImpl = target; } @@ -2068,8 +2068,8 @@ internal sealed partial class LazyIncrementExpression : BaseIncrementExpression, { private readonly Lazy _lazyTarget; - public LazyIncrementExpression(UnaryOperationKind incrementOperationKind, Lazy target, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(incrementOperationKind, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue) + public LazyIncrementExpression(UnaryOperationKind incrementOperationKind, Lazy target, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(incrementOperationKind, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue, isImplicit) { _lazyTarget = target ?? throw new System.ArgumentNullException(nameof(target)); } @@ -2082,8 +2082,8 @@ internal sealed partial class LazyIncrementExpression : BaseIncrementExpression, /// internal sealed partial class InstanceReferenceExpression : Operation, IInstanceReferenceExpression { - public InstanceReferenceExpression(InstanceReferenceKind instanceReferenceKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.InstanceReferenceExpression, semanticModel, syntax, type, constantValue) + public InstanceReferenceExpression(InstanceReferenceKind instanceReferenceKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.InstanceReferenceExpression, semanticModel, syntax, type, constantValue, isImplicit) { InstanceReferenceKind = instanceReferenceKind; } @@ -2114,8 +2114,8 @@ public override void Accept(OperationVisitor visitor) /// internal abstract partial class BaseInterpolatedStringExpression : Operation, IInterpolatedStringExpression { - protected BaseInterpolatedStringExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.InterpolatedStringExpression, semanticModel, syntax, type, constantValue) + protected BaseInterpolatedStringExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.InterpolatedStringExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -2149,8 +2149,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class InterpolatedStringExpression : BaseInterpolatedStringExpression, IInterpolatedStringExpression { - public InterpolatedStringExpression(ImmutableArray parts, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public InterpolatedStringExpression(ImmutableArray parts, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { PartsImpl = parts; } @@ -2165,7 +2165,7 @@ internal sealed partial class LazyInterpolatedStringExpression : BaseInterpolate { private readonly Lazy> _lazyParts; - public LazyInterpolatedStringExpression(Lazy> parts, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyInterpolatedStringExpression(Lazy> parts, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyParts = parts; } @@ -2178,8 +2178,8 @@ public LazyInterpolatedStringExpression(Lazy internal abstract partial class BaseInterpolatedStringText : Operation, IInterpolatedStringText { - protected BaseInterpolatedStringText(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.InterpolatedStringText, semanticModel, syntax, type, constantValue) + protected BaseInterpolatedStringText(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.InterpolatedStringText, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -2210,8 +2210,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class InterpolatedStringText : BaseInterpolatedStringText, IInterpolatedStringText { - public InterpolatedStringText(IOperation text, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public InterpolatedStringText(IOperation text, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { TextImpl = text; } @@ -2226,7 +2226,7 @@ internal sealed partial class LazyInterpolatedStringText : BaseInterpolatedStrin { private readonly Lazy _lazyText; - public LazyInterpolatedStringText(Lazy text, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyInterpolatedStringText(Lazy text, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyText = text; } @@ -2239,8 +2239,8 @@ public LazyInterpolatedStringText(Lazy text, SemanticModel semanticM /// internal abstract partial class BaseInterpolation : Operation, IInterpolation { - protected BaseInterpolation(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.Interpolation, semanticModel, syntax, type, constantValue) + protected BaseInterpolation(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.Interpolation, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -2283,8 +2283,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class Interpolation : BaseInterpolation, IInterpolation { - public Interpolation(IOperation expression, IOperation alignment, IOperation formatString, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public Interpolation(IOperation expression, IOperation alignment, IOperation formatString, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ExpressionImpl = expression; AlignmentImpl = alignment; @@ -2305,8 +2305,8 @@ internal sealed partial class LazyInterpolation : BaseInterpolation, IInterpolat private readonly Lazy _lazyAlignment; private readonly Lazy _lazyFormatString; - public LazyInterpolation(Lazy expression, Lazy alignment, Lazy formatString, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public LazyInterpolation(Lazy expression, Lazy alignment, Lazy formatString, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyExpression = expression; _lazyAlignment = alignment; @@ -2326,8 +2326,8 @@ internal sealed partial class LazyInterpolation : BaseInterpolation, IInterpolat /// internal abstract partial class BaseInvalidExpression : Operation, IInvalidExpression { - protected BaseInvalidExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.InvalidExpression, semanticModel, syntax, type, constantValue) + protected BaseInvalidExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.InvalidExpression, semanticModel, syntax, type, constantValue, isImplicit) { } protected abstract ImmutableArray ChildrenImpl { get; } @@ -2351,8 +2351,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class InvalidExpression : BaseInvalidExpression, IInvalidExpression { - public InvalidExpression(ImmutableArray children, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public InvalidExpression(ImmutableArray children, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ChildrenImpl = children; } @@ -2367,7 +2367,7 @@ internal sealed partial class LazyInvalidExpression : BaseInvalidExpression, IIn { private readonly Lazy> _lazyChildren; - public LazyInvalidExpression(Lazy> children, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyInvalidExpression(Lazy> children, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyChildren = children; } @@ -2379,8 +2379,8 @@ public LazyInvalidExpression(Lazy> children, Semantic /// internal abstract partial class BaseInvalidStatement : Operation, IInvalidStatement { - protected BaseInvalidStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.InvalidStatement, semanticModel, syntax, type, constantValue) + protected BaseInvalidStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.InvalidStatement, semanticModel, syntax, type, constantValue, isImplicit) { } protected abstract ImmutableArray ChildrenImpl { get; } @@ -2403,8 +2403,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class InvalidStatement : BaseInvalidStatement, IInvalidStatement { - public InvalidStatement(ImmutableArray children, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public InvalidStatement(ImmutableArray children, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ChildrenImpl = children; } @@ -2418,7 +2418,7 @@ internal sealed partial class LazyInvalidStatement : BaseInvalidStatement, IInva { private readonly Lazy> _lazyChildren; - public LazyInvalidStatement(Lazy> children, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyInvalidStatement(Lazy> children, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyChildren = children; } @@ -2430,8 +2430,8 @@ public LazyInvalidStatement(Lazy> children, SemanticM /// internal abstract partial class BaseInvocationExpression : Operation, IHasArgumentsExpression, IInvocationExpression { - protected BaseInvocationExpression(IMethodSymbol targetMethod, bool isVirtual, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.InvocationExpression, semanticModel, syntax, type, constantValue) + protected BaseInvocationExpression(IMethodSymbol targetMethod, bool isVirtual, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.InvocationExpression, semanticModel, syntax, type, constantValue, isImplicit) { TargetMethod = targetMethod; IsVirtual = isVirtual; @@ -2484,8 +2484,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class InvocationExpression : BaseInvocationExpression, IHasArgumentsExpression, IInvocationExpression { - public InvocationExpression(IMethodSymbol targetMethod, IOperation instance, bool isVirtual, ImmutableArray argumentsInEvaluationOrder, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(targetMethod, isVirtual, semanticModel, syntax, type, constantValue) + public InvocationExpression(IMethodSymbol targetMethod, IOperation instance, bool isVirtual, ImmutableArray argumentsInEvaluationOrder, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(targetMethod, isVirtual, semanticModel, syntax, type, constantValue, isImplicit) { InstanceImpl = instance; ArgumentsInEvaluationOrderImpl = argumentsInEvaluationOrder; @@ -2503,7 +2503,7 @@ internal sealed partial class LazyInvocationExpression : BaseInvocationExpressio private readonly Lazy _lazyInstance; private readonly Lazy> _lazyArgumentsInEvaluationOrder; - public LazyInvocationExpression(IMethodSymbol targetMethod, Lazy instance, bool isVirtual, Lazy> argumentsInEvaluationOrder, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(targetMethod, isVirtual, semanticModel, syntax, type, constantValue) + public LazyInvocationExpression(IMethodSymbol targetMethod, Lazy instance, bool isVirtual, Lazy> argumentsInEvaluationOrder, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(targetMethod, isVirtual, semanticModel, syntax, type, constantValue, isImplicit) { _lazyInstance = instance ?? throw new System.ArgumentNullException(nameof(instance)); _lazyArgumentsInEvaluationOrder = argumentsInEvaluationOrder; @@ -2519,8 +2519,8 @@ public LazyInvocationExpression(IMethodSymbol targetMethod, Lazy ins /// internal abstract partial class BaseIsTypeExpression : Operation, IIsTypeExpression { - protected BaseIsTypeExpression(ITypeSymbol isType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.IsTypeExpression, semanticModel, syntax, type, constantValue) + protected BaseIsTypeExpression(ITypeSymbol isType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.IsTypeExpression, semanticModel, syntax, type, constantValue, isImplicit) { IsType = isType; } @@ -2556,8 +2556,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class IsTypeExpression : BaseIsTypeExpression, IIsTypeExpression { - public IsTypeExpression(IOperation operand, ITypeSymbol isType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(isType, semanticModel, syntax, type, constantValue) + public IsTypeExpression(IOperation operand, ITypeSymbol isType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(isType, semanticModel, syntax, type, constantValue, isImplicit) { OperandImpl = operand; } @@ -2572,7 +2572,7 @@ internal sealed partial class LazyIsTypeExpression : BaseIsTypeExpression, IIsTy { private readonly Lazy _lazyOperand; - public LazyIsTypeExpression(Lazy operand, ITypeSymbol isType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(isType, semanticModel, syntax, type, constantValue) + public LazyIsTypeExpression(Lazy operand, ITypeSymbol isType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(isType, semanticModel, syntax, type, constantValue, isImplicit) { _lazyOperand = operand ?? throw new System.ArgumentNullException(nameof(operand)); } @@ -2585,8 +2585,8 @@ public LazyIsTypeExpression(Lazy operand, ITypeSymbol isType, Semant /// internal abstract partial class BaseLabeledStatement : Operation, ILabeledStatement { - protected BaseLabeledStatement(ILabelSymbol label, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.LabeledStatement, semanticModel, syntax, type, constantValue) + protected BaseLabeledStatement(ILabelSymbol label, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.LabeledStatement, semanticModel, syntax, type, constantValue, isImplicit) { Label = label; } @@ -2621,8 +2621,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class LabeledStatement : BaseLabeledStatement, ILabeledStatement { - public LabeledStatement(ILabelSymbol label, IOperation labeledStatement, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(label, semanticModel, syntax, type, constantValue) + public LabeledStatement(ILabelSymbol label, IOperation labeledStatement, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(label, semanticModel, syntax, type, constantValue, isImplicit) { StatementImpl = labeledStatement; } @@ -2637,7 +2637,7 @@ internal sealed partial class LazyLabeledStatement : BaseLabeledStatement, ILabe { private readonly Lazy _lazyStatement; - public LazyLabeledStatement(ILabelSymbol label, Lazy statement, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(label, semanticModel, syntax, type, constantValue) + public LazyLabeledStatement(ILabelSymbol label, Lazy statement, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(label, semanticModel, syntax, type, constantValue, isImplicit) { _lazyStatement = statement ?? throw new System.ArgumentNullException(nameof(statement)); } @@ -2650,8 +2650,8 @@ public LazyLabeledStatement(ILabelSymbol label, Lazy statement, Sema /// internal abstract partial class BaseLambdaExpression : Operation, ILambdaExpression { - protected BaseLambdaExpression(IMethodSymbol signature, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.LambdaExpression, semanticModel, syntax, type, constantValue) + protected BaseLambdaExpression(IMethodSymbol signature, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.LambdaExpression, semanticModel, syntax, type, constantValue, isImplicit) { Signature = signature; } @@ -2686,8 +2686,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class LambdaExpression : BaseLambdaExpression, ILambdaExpression { - public LambdaExpression(IMethodSymbol signature, IBlockStatement body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(signature, semanticModel, syntax, type, constantValue) + public LambdaExpression(IMethodSymbol signature, IBlockStatement body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(signature, semanticModel, syntax, type, constantValue, isImplicit) { BodyImpl = body; } @@ -2702,7 +2702,7 @@ internal sealed partial class LazyLambdaExpression : BaseLambdaExpression, ILamb { private readonly Lazy _lazyBody; - public LazyLambdaExpression(IMethodSymbol signature, Lazy body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(signature, semanticModel, syntax, type, constantValue) + public LazyLambdaExpression(IMethodSymbol signature, Lazy body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(signature, semanticModel, syntax, type, constantValue, isImplicit) { _lazyBody = body ?? throw new System.ArgumentNullException(nameof(body)); } @@ -2715,8 +2715,8 @@ public LazyLambdaExpression(IMethodSymbol signature, Lazy body, /// internal abstract partial class BaseDynamicMemberReferenceExpression : Operation, IDynamicMemberReferenceExpression { - protected BaseDynamicMemberReferenceExpression(string memberName, ImmutableArray typeArguments, ITypeSymbol containingType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.DynamicMemberReferenceExpression, semanticModel, syntax, type, constantValue) + protected BaseDynamicMemberReferenceExpression(string memberName, ImmutableArray typeArguments, ITypeSymbol containingType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.DynamicMemberReferenceExpression, semanticModel, syntax, type, constantValue, isImplicit) { MemberName = memberName; TypeArguments = typeArguments; @@ -2764,8 +2764,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class DynamicMemberReferenceExpression : BaseDynamicMemberReferenceExpression, IDynamicMemberReferenceExpression { - public DynamicMemberReferenceExpression(IOperation instance, string memberName, ImmutableArray typeArguments, ITypeSymbol containingType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(memberName, typeArguments, containingType, semanticModel, syntax, type, constantValue) + public DynamicMemberReferenceExpression(IOperation instance, string memberName, ImmutableArray typeArguments, ITypeSymbol containingType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(memberName, typeArguments, containingType, semanticModel, syntax, type, constantValue, isImplicit) { InstanceImpl = instance; } @@ -2780,8 +2780,8 @@ internal sealed partial class LazyDynamicMemberReferenceExpression : BaseDynamic { private readonly Lazy _lazyInstance; - public LazyDynamicMemberReferenceExpression(Lazy lazyInstance, string memberName, ImmutableArray typeArguments, ITypeSymbol containingType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(memberName, typeArguments, containingType, semanticModel, syntax, type, constantValue) + public LazyDynamicMemberReferenceExpression(Lazy lazyInstance, string memberName, ImmutableArray typeArguments, ITypeSymbol containingType, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(memberName, typeArguments, containingType, semanticModel, syntax, type, constantValue, isImplicit) { _lazyInstance = lazyInstance; } @@ -2794,8 +2794,8 @@ internal sealed partial class LazyDynamicMemberReferenceExpression : BaseDynamic /// internal sealed partial class LiteralExpression : Operation, ILiteralExpression { - public LiteralExpression(string text, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.LiteralExpression, semanticModel, syntax, type, constantValue) + public LiteralExpression(string text, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.LiteralExpression, semanticModel, syntax, type, constantValue, isImplicit) { Text = text; } @@ -2825,8 +2825,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class LocalReferenceExpression : Operation, ILocalReferenceExpression { - public LocalReferenceExpression(ILocalSymbol local, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.LocalReferenceExpression, semanticModel, syntax, type, constantValue) + public LocalReferenceExpression(ILocalSymbol local, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.LocalReferenceExpression, semanticModel, syntax, type, constantValue, isImplicit) { Local = local; } @@ -2856,8 +2856,8 @@ public override void Accept(OperationVisitor visitor) /// internal abstract partial class BaseLockStatement : Operation, ILockStatement { - protected BaseLockStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.LockStatement, semanticModel, syntax, type, constantValue) + protected BaseLockStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.LockStatement, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -2894,8 +2894,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class LockStatement : BaseLockStatement, ILockStatement { - public LockStatement(IOperation lockedObject, IOperation body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public LockStatement(IOperation lockedObject, IOperation body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { LockedObjectImpl = lockedObject; BodyImpl = body; @@ -2913,7 +2913,7 @@ internal sealed partial class LazyLockStatement : BaseLockStatement, ILockStatem private readonly Lazy _lazyLockedObject; private readonly Lazy _lazyBody; - public LazyLockStatement(Lazy lockedObject, Lazy body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyLockStatement(Lazy lockedObject, Lazy body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyLockedObject = lockedObject ?? throw new System.ArgumentNullException(nameof(lockedObject)); _lazyBody = body ?? throw new System.ArgumentNullException(nameof(body)); @@ -2929,8 +2929,8 @@ public LazyLockStatement(Lazy lockedObject, Lazy body, S /// internal abstract partial class LoopStatement : Operation, ILoopStatement { - protected LoopStatement(LoopKind loopKind, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(kind, semanticModel, syntax, type, constantValue) + protected LoopStatement(LoopKind loopKind, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(kind, semanticModel, syntax, type, constantValue, isImplicit) { LoopKind = loopKind; } @@ -2950,8 +2950,8 @@ internal abstract partial class LoopStatement : Operation, ILoopStatement /// internal abstract partial class MemberReferenceExpression : Operation, IMemberReferenceExpression { - protected MemberReferenceExpression(ISymbol member, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(kind, semanticModel, syntax, type, constantValue) + protected MemberReferenceExpression(ISymbol member, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(kind, semanticModel, syntax, type, constantValue, isImplicit) { Member = member; } @@ -2972,8 +2972,8 @@ internal abstract partial class MemberReferenceExpression : Operation, IMemberRe /// internal abstract partial class BaseMethodBindingExpression : MemberReferenceExpression, IMethodBindingExpression { - public BaseMethodBindingExpression(IMethodSymbol method, bool isVirtual, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(member, OperationKind.MethodBindingExpression, semanticModel, syntax, type, constantValue) + public BaseMethodBindingExpression(IMethodSymbol method, bool isVirtual, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(member, OperationKind.MethodBindingExpression, semanticModel, syntax, type, constantValue, isImplicit) { Method = method; IsVirtual = isVirtual; @@ -3010,8 +3010,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class MethodBindingExpression : BaseMethodBindingExpression, IMethodBindingExpression { - public MethodBindingExpression(IMethodSymbol method, bool isVirtual, IOperation instance, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(method, isVirtual, member, semanticModel, syntax, type, constantValue) + public MethodBindingExpression(IMethodSymbol method, bool isVirtual, IOperation instance, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(method, isVirtual, member, semanticModel, syntax, type, constantValue, isImplicit) { InstanceImpl = instance; } @@ -3028,8 +3028,8 @@ internal sealed partial class LazyMethodBindingExpression : BaseMethodBindingExp { private readonly Lazy _lazyInstance; - public LazyMethodBindingExpression(IMethodSymbol method, bool isVirtual, Lazy instance, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(method, isVirtual, member, semanticModel, syntax, type, constantValue) + public LazyMethodBindingExpression(IMethodSymbol method, bool isVirtual, Lazy instance, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(method, isVirtual, member, semanticModel, syntax, type, constantValue, isImplicit) { _lazyInstance = instance ?? throw new System.ArgumentNullException(nameof(instance)); } @@ -3041,8 +3041,8 @@ internal sealed partial class LazyMethodBindingExpression : BaseMethodBindingExp /// internal abstract partial class BaseNullCoalescingExpression : Operation, INullCoalescingExpression { - protected BaseNullCoalescingExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.NullCoalescingExpression, semanticModel, syntax, type, constantValue) + protected BaseNullCoalescingExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.NullCoalescingExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -3079,8 +3079,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class NullCoalescingExpression : BaseNullCoalescingExpression, INullCoalescingExpression { - public NullCoalescingExpression(IOperation primaryOperand, IOperation secondaryOperand, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public NullCoalescingExpression(IOperation primaryOperand, IOperation secondaryOperand, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { PrimaryOperandImpl = primaryOperand; SecondaryOperandImpl = secondaryOperand; @@ -3098,7 +3098,7 @@ internal sealed partial class LazyNullCoalescingExpression : BaseNullCoalescingE private readonly Lazy _lazyPrimaryOperand; private readonly Lazy _lazySecondaryOperand; - public LazyNullCoalescingExpression(Lazy primaryOperand, Lazy secondaryOperand, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyNullCoalescingExpression(Lazy primaryOperand, Lazy secondaryOperand, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyPrimaryOperand = primaryOperand ?? throw new System.ArgumentNullException(nameof(primaryOperand)); _lazySecondaryOperand = secondaryOperand ?? throw new System.ArgumentNullException(nameof(secondaryOperand)); @@ -3114,8 +3114,8 @@ public LazyNullCoalescingExpression(Lazy primaryOperand, Lazy internal abstract partial class BaseObjectCreationExpression : Operation, IHasArgumentsExpression, IObjectCreationExpression { - protected BaseObjectCreationExpression(IMethodSymbol constructor, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ObjectCreationExpression, semanticModel, syntax, type, constantValue) + protected BaseObjectCreationExpression(IMethodSymbol constructor, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ObjectCreationExpression, semanticModel, syntax, type, constantValue, isImplicit) { Constructor = constructor; } @@ -3144,7 +3144,7 @@ public override IEnumerable Children /// Arguments of the invocation, excluding the instance argument. Arguments are in evaluation order. /// /// - /// If the invocation is in its expanded form, then params/ParamArray arguments would be collected into arrays. + /// If the invocation is in its expanded form, then params/ParamArray arguments would be collected into arrays. /// Default values are supplied for optional arguments missing in source. /// public ImmutableArray ArgumentsInEvaluationOrder => Operation.SetParentOperation(ArgumentsInEvaluationOrderImpl, this); @@ -3163,8 +3163,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ObjectCreationExpression : BaseObjectCreationExpression, IHasArgumentsExpression, IObjectCreationExpression { - public ObjectCreationExpression(IMethodSymbol constructor, IObjectOrCollectionInitializerExpression initializer, ImmutableArray argumentsInEvaluationOrder, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(constructor, semanticModel, syntax, type, constantValue) + public ObjectCreationExpression(IMethodSymbol constructor, IObjectOrCollectionInitializerExpression initializer, ImmutableArray argumentsInEvaluationOrder, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(constructor, semanticModel, syntax, type, constantValue, isImplicit) { InitializerImpl = initializer; ArgumentsInEvaluationOrderImpl = argumentsInEvaluationOrder; @@ -3182,7 +3182,7 @@ internal sealed partial class LazyObjectCreationExpression : BaseObjectCreationE private readonly Lazy _lazyInitializer; private readonly Lazy> _lazyArgumentsInEvaluationOrder; - public LazyObjectCreationExpression(IMethodSymbol constructor, Lazy initializer, Lazy> argumentsInEvaluationOrder, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(constructor, semanticModel, syntax, type, constantValue) + public LazyObjectCreationExpression(IMethodSymbol constructor, Lazy initializer, Lazy> argumentsInEvaluationOrder, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(constructor, semanticModel, syntax, type, constantValue, isImplicit) { _lazyInitializer = initializer; _lazyArgumentsInEvaluationOrder = argumentsInEvaluationOrder; @@ -3199,8 +3199,8 @@ public LazyObjectCreationExpression(IMethodSymbol constructor, Lazy internal abstract partial class BaseAnonymousObjectCreationExpression : Operation, IAnonymousObjectCreationExpression { - protected BaseAnonymousObjectCreationExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.AnonymousObjectCreationExpression, semanticModel, syntax, type, constantValue) + protected BaseAnonymousObjectCreationExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.AnonymousObjectCreationExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -3234,8 +3234,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class AnonymousObjectCreationExpression : BaseAnonymousObjectCreationExpression, IAnonymousObjectCreationExpression { - public AnonymousObjectCreationExpression(ImmutableArray initializers, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public AnonymousObjectCreationExpression(ImmutableArray initializers, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { InitializersImpl = initializers; } @@ -3250,8 +3250,8 @@ internal sealed partial class LazyAnonymousObjectCreationExpression : BaseAnonym { private readonly Lazy> _lazyInitializers; - public LazyAnonymousObjectCreationExpression(Lazy> initializers, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public LazyAnonymousObjectCreationExpression(Lazy> initializers, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyInitializers = initializers; } @@ -3264,8 +3264,8 @@ internal sealed partial class LazyAnonymousObjectCreationExpression : BaseAnonym /// internal sealed partial class OmittedArgumentExpression : Operation, IOmittedArgumentExpression { - public OmittedArgumentExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.OmittedArgumentExpression, semanticModel, syntax, type, constantValue) + public OmittedArgumentExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.OmittedArgumentExpression, semanticModel, syntax, type, constantValue, isImplicit) { } public override IEnumerable Children @@ -3290,8 +3290,8 @@ public override void Accept(OperationVisitor visitor) /// internal abstract partial class BaseParameterInitializer : SymbolInitializer, IParameterInitializer { - public BaseParameterInitializer(IParameterSymbol parameter, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(kind, semanticModel, syntax, type, constantValue) + public BaseParameterInitializer(IParameterSymbol parameter, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(kind, semanticModel, syntax, type, constantValue, isImplicit) { Parameter = parameter; } @@ -3322,8 +3322,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ParameterInitializer : BaseParameterInitializer, IParameterInitializer { - public ParameterInitializer(IParameterSymbol parameter, IOperation value, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(parameter, kind, semanticModel, syntax, type, constantValue) + public ParameterInitializer(IParameterSymbol parameter, IOperation value, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(parameter, kind, semanticModel, syntax, type, constantValue, isImplicit) { ValueImpl = value; } @@ -3337,8 +3337,8 @@ internal sealed partial class LazyParameterInitializer : BaseParameterInitialize { private readonly Lazy _lazyValue; - public LazyParameterInitializer(IParameterSymbol parameter, Lazy value, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(parameter, kind, semanticModel, syntax, type, constantValue) + public LazyParameterInitializer(IParameterSymbol parameter, Lazy value, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(parameter, kind, semanticModel, syntax, type, constantValue, isImplicit) { _lazyValue = value ?? throw new System.ArgumentNullException(nameof(value)); } @@ -3350,8 +3350,8 @@ internal sealed partial class LazyParameterInitializer : BaseParameterInitialize /// internal sealed partial class ParameterReferenceExpression : Operation, IParameterReferenceExpression { - public ParameterReferenceExpression(IParameterSymbol parameter, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ParameterReferenceExpression, semanticModel, syntax, type, constantValue) + public ParameterReferenceExpression(IParameterSymbol parameter, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ParameterReferenceExpression, semanticModel, syntax, type, constantValue, isImplicit) { Parameter = parameter; } @@ -3381,8 +3381,8 @@ public override void Accept(OperationVisitor visitor) /// internal abstract partial class BaseParenthesizedExpression : Operation, IParenthesizedExpression { - protected BaseParenthesizedExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ParenthesizedExpression, semanticModel, syntax, type, constantValue) + protected BaseParenthesizedExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ParenthesizedExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -3413,8 +3413,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ParenthesizedExpression : BaseParenthesizedExpression, IParenthesizedExpression { - public ParenthesizedExpression(IOperation operand, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public ParenthesizedExpression(IOperation operand, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { OperandImpl = operand; } @@ -3429,7 +3429,7 @@ internal sealed partial class LazyParenthesizedExpression : BaseParenthesizedExp { private readonly Lazy _lazyOperand; - public LazyParenthesizedExpression(Lazy operand, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyParenthesizedExpression(Lazy operand, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyOperand = operand ?? throw new System.ArgumentNullException(nameof(operand)); } @@ -3443,8 +3443,8 @@ public LazyParenthesizedExpression(Lazy operand, SemanticModel seman /// internal sealed partial class PlaceholderExpression : Operation, IPlaceholderExpression { - public PlaceholderExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.PlaceholderExpression, semanticModel, syntax, type, constantValue) + public PlaceholderExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.PlaceholderExpression, semanticModel, syntax, type, constantValue, isImplicit) { } public override IEnumerable Children @@ -3469,8 +3469,8 @@ public override void Accept(OperationVisitor visitor) /// internal abstract partial class BasePointerIndirectionReferenceExpression : Operation, IPointerIndirectionReferenceExpression { - protected BasePointerIndirectionReferenceExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.PointerIndirectionReferenceExpression, semanticModel, syntax, type, constantValue) + protected BasePointerIndirectionReferenceExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.PointerIndirectionReferenceExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -3501,8 +3501,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class PointerIndirectionReferenceExpression : BasePointerIndirectionReferenceExpression, IPointerIndirectionReferenceExpression { - public PointerIndirectionReferenceExpression(IOperation pointer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public PointerIndirectionReferenceExpression(IOperation pointer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { PointerImpl = pointer; } @@ -3517,7 +3517,7 @@ internal sealed partial class LazyPointerIndirectionReferenceExpression : BasePo { private readonly Lazy _lazyPointer; - public LazyPointerIndirectionReferenceExpression(Lazy pointer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyPointerIndirectionReferenceExpression(Lazy pointer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyPointer = pointer ?? throw new System.ArgumentNullException(nameof(pointer)); } @@ -3530,8 +3530,8 @@ public LazyPointerIndirectionReferenceExpression(Lazy pointer, Seman /// internal abstract partial class BasePropertyInitializer : SymbolInitializer, IPropertyInitializer { - public BasePropertyInitializer(IPropertySymbol initializedProperty, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(kind, semanticModel, syntax, type, constantValue) + public BasePropertyInitializer(IPropertySymbol initializedProperty, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(kind, semanticModel, syntax, type, constantValue, isImplicit) { InitializedProperty = initializedProperty; } @@ -3562,8 +3562,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class PropertyInitializer : BasePropertyInitializer, IPropertyInitializer { - public PropertyInitializer(IPropertySymbol initializedProperty, IOperation value, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(initializedProperty, kind, semanticModel, syntax, type, constantValue) + public PropertyInitializer(IPropertySymbol initializedProperty, IOperation value, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(initializedProperty, kind, semanticModel, syntax, type, constantValue, isImplicit) { ValueImpl = value; } @@ -3577,8 +3577,8 @@ internal sealed partial class LazyPropertyInitializer : BasePropertyInitializer, { private readonly Lazy _lazyValue; - public LazyPropertyInitializer(IPropertySymbol initializedProperty, Lazy value, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(initializedProperty, kind, semanticModel, syntax, type, constantValue) + public LazyPropertyInitializer(IPropertySymbol initializedProperty, Lazy value, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(initializedProperty, kind, semanticModel, syntax, type, constantValue, isImplicit) { _lazyValue = value ?? throw new System.ArgumentNullException(nameof(value)); } @@ -3590,8 +3590,8 @@ internal sealed partial class LazyPropertyInitializer : BasePropertyInitializer, /// internal abstract partial class BasePropertyReferenceExpression : MemberReferenceExpression, IPropertyReferenceExpression, IHasArgumentsExpression { - protected BasePropertyReferenceExpression(IPropertySymbol property, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(member, OperationKind.PropertyReferenceExpression, semanticModel, syntax, type, constantValue) + protected BasePropertyReferenceExpression(IPropertySymbol property, ISymbol member, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(member, OperationKind.PropertyReferenceExpression, semanticModel, syntax, type, constantValue, isImplicit) { Property = property; } @@ -3615,7 +3615,7 @@ public override IEnumerable Children /// Arguments of the invocation, excluding the instance argument. Arguments are in evaluation order. /// /// - /// If the invocation is in its expanded form, then params/ParamArray arguments would be collected into arrays. + /// If the invocation is in its expanded form, then params/ParamArray arguments would be collected into arrays. /// Default values are supplied for optional arguments missing in source. /// public ImmutableArray ArgumentsInEvaluationOrder => Operation.SetParentOperation(ArgumentsInEvaluationOrderImpl, this); @@ -3635,8 +3635,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class PropertyReferenceExpression : BasePropertyReferenceExpression, IPropertyReferenceExpression, IHasArgumentsExpression { - public PropertyReferenceExpression(IPropertySymbol property, IOperation instance, ISymbol member, ImmutableArray argumentsInEvaluationOrder, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(property, member, semanticModel, syntax, type, constantValue) + public PropertyReferenceExpression(IPropertySymbol property, IOperation instance, ISymbol member, ImmutableArray argumentsInEvaluationOrder, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(property, member, semanticModel, syntax, type, constantValue, isImplicit) { InstanceImpl = instance; ArgumentsInEvaluationOrderImpl = argumentsInEvaluationOrder; @@ -3662,8 +3662,8 @@ internal sealed partial class LazyPropertyReferenceExpression : BasePropertyRefe private readonly Lazy _lazyInstance; private readonly Lazy> _lazyArgumentsInEvaluationOrder; - public LazyPropertyReferenceExpression(IPropertySymbol property, Lazy instance, ISymbol member, Lazy> argumentsInEvaluationOrder, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(property, member, semanticModel, syntax, type, constantValue) + public LazyPropertyReferenceExpression(IPropertySymbol property, Lazy instance, ISymbol member, Lazy> argumentsInEvaluationOrder, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(property, member, semanticModel, syntax, type, constantValue, isImplicit) { _lazyInstance = instance ?? throw new System.ArgumentNullException(nameof(instance)); _lazyArgumentsInEvaluationOrder = argumentsInEvaluationOrder ?? throw new System.ArgumentNullException(nameof(argumentsInEvaluationOrder)); @@ -3687,8 +3687,8 @@ public override void Accept(OperationVisitor visitor) /// internal abstract partial class BaseRangeCaseClause : CaseClause, IRangeCaseClause { - public BaseRangeCaseClause(CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(caseKind, OperationKind.RangeCaseClause, semanticModel, syntax, type, constantValue) + public BaseRangeCaseClause(CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(caseKind, OperationKind.RangeCaseClause, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -3726,8 +3726,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class RangeCaseClause : BaseRangeCaseClause, IRangeCaseClause { - public RangeCaseClause(IOperation minimumValue, IOperation maximumValue, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(caseKind, semanticModel, syntax, type, constantValue) + public RangeCaseClause(IOperation minimumValue, IOperation maximumValue, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(caseKind, semanticModel, syntax, type, constantValue, isImplicit) { MinimumValueImpl = minimumValue; MaximumValueImpl = maximumValue; @@ -3745,8 +3745,8 @@ internal sealed partial class LazyRangeCaseClause : BaseRangeCaseClause, IRangeC private readonly Lazy _lazyMinimumValue; private readonly Lazy _lazyMaximumValue; - public LazyRangeCaseClause(Lazy minimumValue, Lazy maximumValue, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(caseKind, semanticModel, syntax, type, constantValue) + public LazyRangeCaseClause(Lazy minimumValue, Lazy maximumValue, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(caseKind, semanticModel, syntax, type, constantValue, isImplicit) { _lazyMinimumValue = minimumValue ?? throw new System.ArgumentNullException(nameof(minimumValue)); _lazyMaximumValue = maximumValue ?? throw new System.ArgumentNullException(nameof(maximumValue)); @@ -3762,8 +3762,8 @@ internal sealed partial class LazyRangeCaseClause : BaseRangeCaseClause, IRangeC /// internal abstract partial class BaseRelationalCaseClause : CaseClause, IRelationalCaseClause { - public BaseRelationalCaseClause(BinaryOperationKind relation, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(caseKind, OperationKind.RelationalCaseClause, semanticModel, syntax, type, constantValue) + public BaseRelationalCaseClause(BinaryOperationKind relation, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(caseKind, OperationKind.RelationalCaseClause, semanticModel, syntax, type, constantValue, isImplicit) { Relation = relation; } @@ -3800,8 +3800,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class RelationalCaseClause : BaseRelationalCaseClause, IRelationalCaseClause { - public RelationalCaseClause(IOperation value, BinaryOperationKind relation, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(relation, caseKind, semanticModel, syntax, type, constantValue) + public RelationalCaseClause(IOperation value, BinaryOperationKind relation, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(relation, caseKind, semanticModel, syntax, type, constantValue, isImplicit) { ValueImpl = value; } @@ -3816,8 +3816,8 @@ internal sealed partial class LazyRelationalCaseClause : BaseRelationalCaseClaus { private readonly Lazy _lazyValue; - public LazyRelationalCaseClause(Lazy value, BinaryOperationKind relation, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(relation, caseKind, semanticModel, syntax, type, constantValue) + public LazyRelationalCaseClause(Lazy value, BinaryOperationKind relation, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(relation, caseKind, semanticModel, syntax, type, constantValue, isImplicit) { _lazyValue = value ?? throw new System.ArgumentNullException(nameof(value)); } @@ -3830,8 +3830,8 @@ internal sealed partial class LazyRelationalCaseClause : BaseRelationalCaseClaus /// internal abstract partial class BaseReturnStatement : Operation, IReturnStatement { - protected BaseReturnStatement(OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(kind, semanticModel, syntax, type, constantValue) + protected BaseReturnStatement(OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(kind, semanticModel, syntax, type, constantValue, isImplicit) { Debug.Assert(kind == OperationKind.ReturnStatement || kind == OperationKind.YieldReturnStatement @@ -3879,8 +3879,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ReturnStatement : BaseReturnStatement, IReturnStatement { - public ReturnStatement(OperationKind kind, IOperation returnedValue, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(kind, semanticModel, syntax, type, constantValue) + public ReturnStatement(OperationKind kind, IOperation returnedValue, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(kind, semanticModel, syntax, type, constantValue, isImplicit) { ReturnedValueImpl = returnedValue; } @@ -3895,7 +3895,7 @@ internal sealed partial class LazyReturnStatement : BaseReturnStatement, IReturn { private readonly Lazy _lazyReturnedValue; - public LazyReturnStatement(OperationKind kind, Lazy returnedValue, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(kind, semanticModel, syntax, type, constantValue) + public LazyReturnStatement(OperationKind kind, Lazy returnedValue, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(kind, semanticModel, syntax, type, constantValue, isImplicit) { _lazyReturnedValue = returnedValue ?? throw new System.ArgumentNullException(nameof(returnedValue)); } @@ -3908,8 +3908,8 @@ public LazyReturnStatement(OperationKind kind, Lazy returnedValue, S /// internal abstract partial class BaseSingleValueCaseClause : CaseClause, ISingleValueCaseClause { - public BaseSingleValueCaseClause(BinaryOperationKind equality, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(caseKind, OperationKind.SingleValueCaseClause, semanticModel, syntax, type, constantValue) + public BaseSingleValueCaseClause(BinaryOperationKind equality, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(caseKind, OperationKind.SingleValueCaseClause, semanticModel, syntax, type, constantValue, isImplicit) { Equality = equality; } @@ -3946,8 +3946,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class SingleValueCaseClause : BaseSingleValueCaseClause, ISingleValueCaseClause { - public SingleValueCaseClause(IOperation value, BinaryOperationKind equality, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(equality, caseKind, semanticModel, syntax, type, constantValue) + public SingleValueCaseClause(IOperation value, BinaryOperationKind equality, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(equality, caseKind, semanticModel, syntax, type, constantValue, isImplicit) { ValueImpl = value; } @@ -3962,8 +3962,8 @@ internal sealed partial class LazySingleValueCaseClause : BaseSingleValueCaseCla { private readonly Lazy _lazyValue; - public LazySingleValueCaseClause(Lazy value, BinaryOperationKind equality, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(equality, caseKind, semanticModel, syntax, type, constantValue) + public LazySingleValueCaseClause(Lazy value, BinaryOperationKind equality, CaseKind caseKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(equality, caseKind, semanticModel, syntax, type, constantValue, isImplicit) { _lazyValue = value ?? throw new System.ArgumentNullException(nameof(value)); } @@ -3976,8 +3976,8 @@ internal sealed partial class LazySingleValueCaseClause : BaseSingleValueCaseCla /// internal sealed partial class DefaultCaseClause : CaseClause, IDefaultCaseClause { - public DefaultCaseClause(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(CaseKind.Default, OperationKind.DefaultCaseClause, semanticModel, syntax, type, constantValue) + public DefaultCaseClause(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(CaseKind.Default, OperationKind.DefaultCaseClause, semanticModel, syntax, type, constantValue, isImplicit) { } public override IEnumerable Children @@ -4002,8 +4002,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class SizeOfExpression : TypeOperationExpression, ISizeOfExpression { - public SizeOfExpression(ITypeSymbol typeOperand, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(typeOperand, OperationKind.SizeOfExpression, semanticModel, syntax, type, constantValue) + public SizeOfExpression(ITypeSymbol typeOperand, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(typeOperand, OperationKind.SizeOfExpression, semanticModel, syntax, type, constantValue, isImplicit) { } public override IEnumerable Children @@ -4028,8 +4028,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class StopStatement : Operation, IStopStatement { - public StopStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.StopStatement, semanticModel, syntax, type, constantValue) + public StopStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.StopStatement, semanticModel, syntax, type, constantValue, isImplicit) { } public override IEnumerable Children @@ -4054,8 +4054,8 @@ public override void Accept(OperationVisitor visitor) /// internal abstract partial class BaseSwitchCase : Operation, ISwitchCase { - protected BaseSwitchCase(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.SwitchCase, semanticModel, syntax, type, constantValue) + protected BaseSwitchCase(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.SwitchCase, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -4098,8 +4098,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class SwitchCase : BaseSwitchCase, ISwitchCase { - public SwitchCase(ImmutableArray clauses, ImmutableArray body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public SwitchCase(ImmutableArray clauses, ImmutableArray body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ClausesImpl = clauses; BodyImpl = body; @@ -4117,7 +4117,7 @@ internal sealed partial class LazySwitchCase : BaseSwitchCase, ISwitchCase private readonly Lazy> _lazyClauses; private readonly Lazy> _lazyBody; - public LazySwitchCase(Lazy> clauses, Lazy> body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazySwitchCase(Lazy> clauses, Lazy> body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyClauses = clauses; _lazyBody = body; @@ -4133,8 +4133,8 @@ public LazySwitchCase(Lazy> clauses, Lazy internal abstract partial class BaseSwitchStatement : Operation, ISwitchStatement { - protected BaseSwitchStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.SwitchStatement, semanticModel, syntax, type, constantValue) + protected BaseSwitchStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.SwitchStatement, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -4174,8 +4174,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class SwitchStatement : BaseSwitchStatement, ISwitchStatement { - public SwitchStatement(IOperation value, ImmutableArray cases, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public SwitchStatement(IOperation value, ImmutableArray cases, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ValueImpl = value; CasesImpl = cases; @@ -4193,7 +4193,7 @@ internal sealed partial class LazySwitchStatement : BaseSwitchStatement, ISwitch private readonly Lazy _lazyValue; private readonly Lazy> _lazyCases; - public LazySwitchStatement(Lazy value, Lazy> cases, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazySwitchStatement(Lazy value, Lazy> cases, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyValue = value ?? throw new System.ArgumentNullException(nameof(value)); _lazyCases = cases; @@ -4209,8 +4209,8 @@ public LazySwitchStatement(Lazy value, Lazy internal abstract partial class SymbolInitializer : Operation, ISymbolInitializer { - protected SymbolInitializer(OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(kind, semanticModel, syntax, type, constantValue) + protected SymbolInitializer(OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(kind, semanticModel, syntax, type, constantValue, isImplicit) { } protected abstract IOperation ValueImpl { get; } @@ -4222,8 +4222,8 @@ internal abstract partial class SymbolInitializer : Operation, ISymbolInitialize /// internal abstract partial class BaseSyntheticLocalReferenceExpression : Operation, ISyntheticLocalReferenceExpression { - protected BaseSyntheticLocalReferenceExpression(SyntheticLocalKind syntheticLocalKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.SyntheticLocalReferenceExpression, semanticModel, syntax, type, constantValue) + protected BaseSyntheticLocalReferenceExpression(SyntheticLocalKind syntheticLocalKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.SyntheticLocalReferenceExpression, semanticModel, syntax, type, constantValue, isImplicit) { SyntheticLocalKind = syntheticLocalKind; } @@ -4254,8 +4254,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class SyntheticLocalReferenceExpression : BaseSyntheticLocalReferenceExpression, ISyntheticLocalReferenceExpression { - public SyntheticLocalReferenceExpression(SyntheticLocalKind syntheticLocalKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(syntheticLocalKind, semanticModel, syntax, type, constantValue) + public SyntheticLocalReferenceExpression(SyntheticLocalKind syntheticLocalKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(syntheticLocalKind, semanticModel, syntax, type, constantValue, isImplicit) { } } @@ -4265,8 +4265,8 @@ internal sealed partial class SyntheticLocalReferenceExpression : BaseSyntheticL /// internal sealed partial class LazySyntheticLocalReferenceExpression : BaseSyntheticLocalReferenceExpression, ISyntheticLocalReferenceExpression { - public LazySyntheticLocalReferenceExpression(SyntheticLocalKind syntheticLocalKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(syntheticLocalKind, semanticModel, syntax, type, constantValue) + public LazySyntheticLocalReferenceExpression(SyntheticLocalKind syntheticLocalKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(syntheticLocalKind, semanticModel, syntax, type, constantValue, isImplicit) { } } @@ -4276,8 +4276,8 @@ internal sealed partial class LazySyntheticLocalReferenceExpression : BaseSynthe /// internal abstract partial class BaseThrowStatement : Operation, IThrowStatement { - protected BaseThrowStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ThrowStatement, semanticModel, syntax, type, constantValue) + protected BaseThrowStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ThrowStatement, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -4308,8 +4308,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ThrowStatement : BaseThrowStatement, IThrowStatement { - public ThrowStatement(IOperation thrownObject, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public ThrowStatement(IOperation thrownObject, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ThrownObjectImpl = thrownObject; } @@ -4324,7 +4324,7 @@ internal sealed partial class LazyThrowStatement : BaseThrowStatement, IThrowSta { private readonly Lazy _lazyThrownObject; - public LazyThrowStatement(Lazy thrownObject, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyThrowStatement(Lazy thrownObject, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyThrownObject = thrownObject ?? throw new System.ArgumentNullException(nameof(thrownObject)); } @@ -4337,8 +4337,8 @@ public LazyThrowStatement(Lazy thrownObject, SemanticModel semanticM /// internal abstract partial class BaseTryStatement : Operation, ITryStatement { - protected BaseTryStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.TryStatement, semanticModel, syntax, type, constantValue) + protected BaseTryStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.TryStatement, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -4384,8 +4384,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class TryStatement : BaseTryStatement, ITryStatement { - public TryStatement(IBlockStatement body, ImmutableArray catches, IBlockStatement finallyHandler, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public TryStatement(IBlockStatement body, ImmutableArray catches, IBlockStatement finallyHandler, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { BodyImpl = body; CatchesImpl = catches; @@ -4406,7 +4406,7 @@ internal sealed partial class LazyTryStatement : BaseTryStatement, ITryStatement private readonly Lazy> _lazyCatches; private readonly Lazy _lazyFinallyHandler; - public LazyTryStatement(Lazy body, Lazy> catches, Lazy finallyHandler, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyTryStatement(Lazy body, Lazy> catches, Lazy finallyHandler, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyBody = body ?? throw new System.ArgumentNullException(nameof(body)); _lazyCatches = catches; @@ -4425,8 +4425,8 @@ public LazyTryStatement(Lazy body, Lazy internal abstract partial class BaseTupleExpression : Operation, ITupleExpression { - protected BaseTupleExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.TupleExpression, semanticModel, syntax, type, constantValue) + protected BaseTupleExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.TupleExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -4460,8 +4460,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class TupleExpression : BaseTupleExpression, ITupleExpression { - public TupleExpression(ImmutableArray elements, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public TupleExpression(ImmutableArray elements, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ElementsImpl = elements; } @@ -4476,8 +4476,8 @@ internal sealed partial class LazyTupleExpression : BaseTupleExpression, ITupleE { private readonly Lazy> _lazyElements; - public LazyTupleExpression(Lazy> elements, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public LazyTupleExpression(Lazy> elements, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyElements = elements; } @@ -4490,8 +4490,8 @@ internal sealed partial class LazyTupleExpression : BaseTupleExpression, ITupleE /// internal sealed partial class TypeOfExpression : TypeOperationExpression, ITypeOfExpression { - public TypeOfExpression(ITypeSymbol typeOperand, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(typeOperand, OperationKind.TypeOfExpression, semanticModel, syntax, type, constantValue) + public TypeOfExpression(ITypeSymbol typeOperand, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(typeOperand, OperationKind.TypeOfExpression, semanticModel, syntax, type, constantValue, isImplicit) { } public override IEnumerable Children @@ -4516,8 +4516,8 @@ public override void Accept(OperationVisitor visitor) /// internal abstract partial class TypeOperationExpression : Operation, ITypeOperationExpression { - protected TypeOperationExpression(ITypeSymbol typeOperand, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(kind, semanticModel, syntax, type, constantValue) + protected TypeOperationExpression(ITypeSymbol typeOperand, OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(kind, semanticModel, syntax, type, constantValue, isImplicit) { TypeOperand = typeOperand; } @@ -4532,8 +4532,8 @@ internal abstract partial class TypeOperationExpression : Operation, ITypeOperat /// internal abstract partial class BaseTypeParameterObjectCreationExpression : Operation, ITypeParameterObjectCreationExpression { - public BaseTypeParameterObjectCreationExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.TypeParameterObjectCreationExpression, semanticModel, syntax, type, constantValue) + public BaseTypeParameterObjectCreationExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.TypeParameterObjectCreationExpression, semanticModel, syntax, type, constantValue, isImplicit) { } protected abstract IObjectOrCollectionInitializerExpression InitializerImpl { get; } @@ -4563,8 +4563,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class TypeParameterObjectCreationExpression : BaseTypeParameterObjectCreationExpression, ITypeParameterObjectCreationExpression { - public TypeParameterObjectCreationExpression(IObjectOrCollectionInitializerExpression initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public TypeParameterObjectCreationExpression(IObjectOrCollectionInitializerExpression initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { InitializerImpl = initializer; } @@ -4577,8 +4577,8 @@ internal sealed partial class TypeParameterObjectCreationExpression : BaseTypePa internal sealed partial class LazyTypeParameterObjectCreationExpression : BaseTypeParameterObjectCreationExpression, ITypeParameterObjectCreationExpression { private readonly Lazy _lazyInitializer; - public LazyTypeParameterObjectCreationExpression(Lazy initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public LazyTypeParameterObjectCreationExpression(Lazy initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyInitializer = initializer ?? throw new System.ArgumentNullException(nameof(initializer)); } @@ -4590,8 +4590,8 @@ internal sealed partial class LazyTypeParameterObjectCreationExpression : BaseTy /// internal abstract partial class BaseDynamicObjectCreationExpression : Operation, IHasDynamicArgumentsExpression, IDynamicObjectCreationExpression { - public BaseDynamicObjectCreationExpression(string name, ImmutableArray applicableSymbols, ImmutableArray argumentNames, ImmutableArray argumentRefKinds, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.TypeParameterObjectCreationExpression, semanticModel, syntax, type, constantValue) + public BaseDynamicObjectCreationExpression(string name, ImmutableArray applicableSymbols, ImmutableArray argumentNames, ImmutableArray argumentRefKinds, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.TypeParameterObjectCreationExpression, semanticModel, syntax, type, constantValue, isImplicit) { Name = name; ApplicableSymbols = applicableSymbols; @@ -4651,8 +4651,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class DynamicObjectCreationExpression : BaseDynamicObjectCreationExpression, IHasDynamicArgumentsExpression, IDynamicObjectCreationExpression { - public DynamicObjectCreationExpression(string name, ImmutableArray applicableSymbols, ImmutableArray arguments, ImmutableArray argumentNames, ImmutableArray argumentRefKinds, IObjectOrCollectionInitializerExpression initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(name, applicableSymbols, argumentNames, argumentRefKinds, semanticModel, syntax, type, constantValue) + public DynamicObjectCreationExpression(string name, ImmutableArray applicableSymbols, ImmutableArray arguments, ImmutableArray argumentNames, ImmutableArray argumentRefKinds, IObjectOrCollectionInitializerExpression initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(name, applicableSymbols, argumentNames, argumentRefKinds, semanticModel, syntax, type, constantValue, isImplicit) { ArgumentsImpl = arguments; InitializerImpl = initializer; @@ -4668,8 +4668,8 @@ internal sealed partial class LazyDynamicObjectCreationExpression : BaseDynamicO { private readonly Lazy _lazyInitializer; private readonly Lazy> _lazyArguments; - public LazyDynamicObjectCreationExpression(string name, ImmutableArray applicableSymbols, Lazy> arguments, ImmutableArray argumentNames, ImmutableArray argumentRefKinds, Lazy initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(name, applicableSymbols, argumentNames, argumentRefKinds, semanticModel, syntax, type, constantValue) + public LazyDynamicObjectCreationExpression(string name, ImmutableArray applicableSymbols, Lazy> arguments, ImmutableArray argumentNames, ImmutableArray argumentRefKinds, Lazy initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(name, applicableSymbols, argumentNames, argumentRefKinds, semanticModel, syntax, type, constantValue, isImplicit) { _lazyArguments = arguments ?? throw new System.ArgumentNullException(nameof(arguments)); _lazyInitializer = initializer ?? throw new System.ArgumentNullException(nameof(initializer)); @@ -4683,8 +4683,8 @@ internal sealed partial class LazyDynamicObjectCreationExpression : BaseDynamicO /// internal abstract partial class BaseUnaryOperatorExpression : Operation, IHasOperatorMethodExpression, IUnaryOperatorExpression { - protected BaseUnaryOperatorExpression(UnaryOperationKind unaryOperationKind, bool isLifted, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.UnaryOperatorExpression, semanticModel, syntax, type, constantValue) + protected BaseUnaryOperatorExpression(UnaryOperationKind unaryOperationKind, bool isLifted, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.UnaryOperatorExpression, semanticModel, syntax, type, constantValue, isImplicit) { UnaryOperationKind = unaryOperationKind; UsesOperatorMethod = usesOperatorMethod; @@ -4733,8 +4733,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class UnaryOperatorExpression : BaseUnaryOperatorExpression, IHasOperatorMethodExpression, IUnaryOperatorExpression { - public UnaryOperatorExpression(UnaryOperationKind unaryOperationKind, IOperation operand, bool isLifted, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(unaryOperationKind, isLifted, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue) + public UnaryOperatorExpression(UnaryOperationKind unaryOperationKind, IOperation operand, bool isLifted, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(unaryOperationKind, isLifted, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue, isImplicit) { OperandImpl = operand; } @@ -4749,8 +4749,8 @@ internal sealed partial class LazyUnaryOperatorExpression : BaseUnaryOperatorExp { private readonly Lazy _lazyOperand; - public LazyUnaryOperatorExpression(UnaryOperationKind unaryOperationKind, Lazy operand, bool isLifted, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(unaryOperationKind, isLifted, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue) + public LazyUnaryOperatorExpression(UnaryOperationKind unaryOperationKind, Lazy operand, bool isLifted, bool usesOperatorMethod, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(unaryOperationKind, isLifted, usesOperatorMethod, operatorMethod, semanticModel, syntax, type, constantValue, isImplicit) { _lazyOperand = operand ?? throw new System.ArgumentNullException(nameof(operand)); } @@ -4763,8 +4763,8 @@ internal sealed partial class LazyUnaryOperatorExpression : BaseUnaryOperatorExp /// internal abstract partial class BaseUsingStatement : Operation, IUsingStatement { - protected BaseUsingStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.UsingStatement, semanticModel, syntax, type, constantValue) + protected BaseUsingStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.UsingStatement, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -4809,8 +4809,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class UsingStatement : BaseUsingStatement, IUsingStatement { - public UsingStatement(IOperation body, IVariableDeclarationStatement declaration, IOperation value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public UsingStatement(IOperation body, IVariableDeclarationStatement declaration, IOperation value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { BodyImpl = body; DeclarationImpl = declaration; @@ -4831,7 +4831,7 @@ internal sealed partial class LazyUsingStatement : BaseUsingStatement, IUsingSta private readonly Lazy _lazyDeclaration; private readonly Lazy _lazyValue; - public LazyUsingStatement(Lazy body, Lazy declaration, Lazy value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyUsingStatement(Lazy body, Lazy declaration, Lazy value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyBody = body ?? throw new System.ArgumentNullException(nameof(body)); _lazyDeclaration = declaration ?? throw new System.ArgumentNullException(nameof(declaration)); @@ -4850,8 +4850,8 @@ public LazyUsingStatement(Lazy body, Lazy internal abstract partial class BaseVariableDeclaration : Operation, IVariableDeclaration { - protected BaseVariableDeclaration(ImmutableArray variables, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.VariableDeclaration, semanticModel, syntax, type, constantValue) + protected BaseVariableDeclaration(ImmutableArray variables, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.VariableDeclaration, semanticModel, syntax, type, constantValue, isImplicit) { Variables = variables; } @@ -4888,8 +4888,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class VariableDeclaration : BaseVariableDeclaration, IVariableDeclaration { - public VariableDeclaration(ImmutableArray variables, IOperation initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(variables, semanticModel, syntax, type, constantValue) + public VariableDeclaration(ImmutableArray variables, IOperation initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(variables, semanticModel, syntax, type, constantValue, isImplicit) { InitializerImpl = initializer; } @@ -4904,7 +4904,7 @@ internal sealed partial class LazyVariableDeclaration : BaseVariableDeclaration, { private readonly Lazy _lazyInitializer; - public LazyVariableDeclaration(ImmutableArray variables, Lazy initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(variables, semanticModel, syntax, type, constantValue) + public LazyVariableDeclaration(ImmutableArray variables, Lazy initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(variables, semanticModel, syntax, type, constantValue, isImplicit) { _lazyInitializer = initializer ?? throw new System.ArgumentNullException(nameof(initializer)); } @@ -4917,8 +4917,8 @@ public LazyVariableDeclaration(ImmutableArray variables, Lazy internal abstract partial class BaseVariableDeclarationStatement : Operation, IVariableDeclarationStatement { - protected BaseVariableDeclarationStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.VariableDeclarationStatement, semanticModel, syntax, type, constantValue) + protected BaseVariableDeclarationStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.VariableDeclarationStatement, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -4952,8 +4952,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class VariableDeclarationStatement : BaseVariableDeclarationStatement, IVariableDeclarationStatement { - public VariableDeclarationStatement(ImmutableArray declarations, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public VariableDeclarationStatement(ImmutableArray declarations, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { DeclarationsImpl = declarations; } @@ -4968,7 +4968,7 @@ internal sealed partial class LazyVariableDeclarationStatement : BaseVariableDec { private readonly Lazy> _lazyDeclarations; - public LazyVariableDeclarationStatement(Lazy> declarations, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyVariableDeclarationStatement(Lazy> declarations, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyDeclarations = declarations; } @@ -4981,8 +4981,8 @@ public LazyVariableDeclarationStatement(Lazy internal abstract partial class BaseWhileUntilLoopStatement : ForWhileUntilLoopStatement, IWhileUntilLoopStatement { - public BaseWhileUntilLoopStatement(bool isTopTest, bool isWhile, LoopKind loopKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(loopKind, OperationKind.LoopStatement, semanticModel, syntax, type, constantValue) + public BaseWhileUntilLoopStatement(bool isTopTest, bool isWhile, LoopKind loopKind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(loopKind, OperationKind.LoopStatement, semanticModel, syntax, type, constantValue, isImplicit) { IsTopTest = isTopTest; IsWhile = isWhile; @@ -5019,8 +5019,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class WhileUntilLoopStatement : BaseWhileUntilLoopStatement, IWhileUntilLoopStatement { - public WhileUntilLoopStatement(bool isTopTest, bool isWhile, IOperation condition, LoopKind loopKind, IOperation body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(isTopTest, isWhile, loopKind, semanticModel, syntax, type, constantValue) + public WhileUntilLoopStatement(bool isTopTest, bool isWhile, IOperation condition, LoopKind loopKind, IOperation body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(isTopTest, isWhile, loopKind, semanticModel, syntax, type, constantValue, isImplicit) { ConditionImpl = condition; BodyImpl = body; @@ -5037,8 +5037,8 @@ internal sealed partial class LazyWhileUntilLoopStatement : BaseWhileUntilLoopSt private readonly Lazy _lazyCondition; private readonly Lazy _lazyBody; - public LazyWhileUntilLoopStatement(bool isTopTest, bool isWhile, Lazy condition, LoopKind loopKind, Lazy body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(isTopTest, isWhile, loopKind, semanticModel, syntax, type, constantValue) + public LazyWhileUntilLoopStatement(bool isTopTest, bool isWhile, Lazy condition, LoopKind loopKind, Lazy body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(isTopTest, isWhile, loopKind, semanticModel, syntax, type, constantValue, isImplicit) { _lazyCondition = condition ?? throw new System.ArgumentNullException(nameof(condition)); _lazyBody = body ?? throw new System.ArgumentNullException(nameof(body)); @@ -5052,8 +5052,8 @@ internal sealed partial class LazyWhileUntilLoopStatement : BaseWhileUntilLoopSt /// internal abstract partial class BaseWithStatement : Operation, IWithStatement { - protected BaseWithStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.WithStatement, semanticModel, syntax, type, constantValue) + protected BaseWithStatement(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.WithStatement, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -5090,8 +5090,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class WithStatement : BaseWithStatement, IWithStatement { - public WithStatement(IOperation body, IOperation value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public WithStatement(IOperation body, IOperation value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { BodyImpl = body; ValueImpl = value; @@ -5109,7 +5109,7 @@ internal sealed partial class LazyWithStatement : BaseWithStatement, IWithStatem private readonly Lazy _lazyBody; private readonly Lazy _lazyValue; - public LazyWithStatement(Lazy body, Lazy value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : base(semanticModel, syntax, type, constantValue) + public LazyWithStatement(Lazy body, Lazy value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyBody = body ?? throw new System.ArgumentNullException(nameof(body)); _lazyValue = value ?? throw new System.ArgumentNullException(nameof(value)); @@ -5125,8 +5125,8 @@ public LazyWithStatement(Lazy body, Lazy value, Semantic /// internal abstract partial class BaseLocalFunctionStatement : Operation, ILocalFunctionStatement { - protected BaseLocalFunctionStatement(IMethodSymbol localFunctionSymbol, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.LocalFunctionStatement, semanticModel, syntax, type, constantValue) + protected BaseLocalFunctionStatement(IMethodSymbol localFunctionSymbol, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.LocalFunctionStatement, semanticModel, syntax, type, constantValue, isImplicit) { LocalFunctionSymbol = localFunctionSymbol; } @@ -5161,8 +5161,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class LocalFunctionStatement : BaseLocalFunctionStatement, ILocalFunctionStatement { - public LocalFunctionStatement(IMethodSymbol localFunctionSymbol, IBlockStatement body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(localFunctionSymbol, semanticModel, syntax, type, constantValue) + public LocalFunctionStatement(IMethodSymbol localFunctionSymbol, IBlockStatement body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(localFunctionSymbol, semanticModel, syntax, type, constantValue, isImplicit) { BodyImpl = body; } @@ -5177,8 +5177,8 @@ internal sealed partial class LazyLocalFunctionStatement : BaseLocalFunctionStat { private readonly Lazy _lazyBody; - public LazyLocalFunctionStatement(IMethodSymbol localFunctionSymbol, Lazy body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) - : base(localFunctionSymbol, semanticModel, syntax, type, constantValue) + public LazyLocalFunctionStatement(IMethodSymbol localFunctionSymbol, Lazy body, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue,bool isImplicit) + : base(localFunctionSymbol, semanticModel, syntax, type, constantValue, isImplicit) { _lazyBody = body ?? throw new System.ArgumentNullException(nameof(body)); } @@ -5191,8 +5191,8 @@ public LazyLocalFunctionStatement(IMethodSymbol localFunctionSymbol, Lazy internal abstract partial class BaseConstantPattern : Operation, IConstantPattern { - protected BaseConstantPattern(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ConstantPattern, semanticModel, syntax, type, constantValue) + protected BaseConstantPattern(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ConstantPattern, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -5223,8 +5223,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ConstantPattern : BaseConstantPattern, IConstantPattern { - public ConstantPattern(IOperation value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public ConstantPattern(IOperation value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ValueImpl = value; } @@ -5239,8 +5239,8 @@ internal sealed partial class LazyConstantPattern : BaseConstantPattern, IConsta { private readonly Lazy _lazyValue; - public LazyConstantPattern(Lazy value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) - : base(semanticModel, syntax, type, constantValue) + public LazyConstantPattern(Lazy value, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) + : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyValue = value ?? throw new System.ArgumentNullException(nameof(value)); } @@ -5253,8 +5253,8 @@ public LazyConstantPattern(Lazy value, SemanticModel semanticModel, /// internal sealed partial class DeclarationPattern : Operation, IDeclarationPattern { - public DeclarationPattern(ISymbol declaredSymbol, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.DeclarationPattern, semanticModel, syntax, type, constantValue) + public DeclarationPattern(ISymbol declaredSymbol, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.DeclarationPattern, semanticModel, syntax, type, constantValue, isImplicit) { DeclaredSymbol = declaredSymbol; } @@ -5284,8 +5284,8 @@ public override void Accept(OperationVisitor visitor) /// internal abstract partial class BasePatternCaseClause : CaseClause, IPatternCaseClause { - protected BasePatternCaseClause(ILabelSymbol label, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(CaseKind.Pattern, OperationKind.PatternCaseClause, semanticModel, syntax, type, constantValue) + protected BasePatternCaseClause(ILabelSymbol label, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(CaseKind.Pattern, OperationKind.PatternCaseClause, semanticModel, syntax, type, constantValue, isImplicit) { Label = label; } @@ -5326,8 +5326,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class PatternCaseClause : BasePatternCaseClause, IPatternCaseClause { - public PatternCaseClause(ILabelSymbol label, IPattern pattern, IOperation guardExpression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(label, semanticModel, syntax, type, constantValue) + public PatternCaseClause(ILabelSymbol label, IPattern pattern, IOperation guardExpression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(label, semanticModel, syntax, type, constantValue, isImplicit) { PatternImpl = pattern; GuardExpressionImpl = guardExpression; @@ -5345,8 +5345,8 @@ internal sealed partial class LazyPatternCaseClause : BasePatternCaseClause, IPa private readonly Lazy _lazyPattern; private readonly Lazy _lazyGuardExpression; - public LazyPatternCaseClause(ILabelSymbol label, Lazy lazyPattern, Lazy lazyGuardExpression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) - : base(label, semanticModel, syntax, type, constantValue) + public LazyPatternCaseClause(ILabelSymbol label, Lazy lazyPattern, Lazy lazyGuardExpression, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) + : base(label, semanticModel, syntax, type, constantValue, isImplicit) { _lazyPattern = lazyPattern ?? throw new System.ArgumentNullException(nameof(lazyPattern)); _lazyGuardExpression = lazyGuardExpression ?? throw new System.ArgumentNullException(nameof(lazyGuardExpression)); @@ -5362,8 +5362,8 @@ public LazyPatternCaseClause(ILabelSymbol label, Lazy lazyPattern, Laz /// internal abstract partial class BaseIsPatternExpression : Operation, IIsPatternExpression { - protected BaseIsPatternExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.IsPatternExpression, semanticModel, syntax, type, constantValue) + protected BaseIsPatternExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.IsPatternExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -5400,8 +5400,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class IsPatternExpression : BaseIsPatternExpression, IIsPatternExpression { - public IsPatternExpression(IOperation expression, IPattern pattern, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public IsPatternExpression(IOperation expression, IPattern pattern, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { ExpressionImpl = expression; PatternImpl = pattern; @@ -5419,8 +5419,8 @@ internal sealed partial class LazyIsPatternExpression : BaseIsPatternExpression, private readonly Lazy _lazyExpression; private readonly Lazy _lazyPattern; - public LazyIsPatternExpression(Lazy lazyExpression, Lazy lazyPattern, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) - : base(semanticModel, syntax, type, constantValue) + public LazyIsPatternExpression(Lazy lazyExpression, Lazy lazyPattern, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) + : base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyExpression = lazyExpression ?? throw new System.ArgumentNullException(nameof(lazyExpression)); _lazyPattern = lazyPattern ?? throw new System.ArgumentNullException(nameof(lazyPattern)); @@ -5436,8 +5436,8 @@ public LazyIsPatternExpression(Lazy lazyExpression, Lazy l /// internal abstract partial class BaseObjectOrCollectionInitializerExpression : Operation, IObjectOrCollectionInitializerExpression { - protected BaseObjectOrCollectionInitializerExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.ObjectOrCollectionInitializerExpression, semanticModel, syntax, type, constantValue) + protected BaseObjectOrCollectionInitializerExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.ObjectOrCollectionInitializerExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -5471,8 +5471,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class ObjectOrCollectionInitializerExpression : BaseObjectOrCollectionInitializerExpression, IObjectOrCollectionInitializerExpression { - public ObjectOrCollectionInitializerExpression(ImmutableArray initializers, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public ObjectOrCollectionInitializerExpression(ImmutableArray initializers, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { InitializersImpl = initializers; } @@ -5487,8 +5487,8 @@ internal sealed partial class LazyObjectOrCollectionInitializerExpression : Base { private readonly Lazy> _lazyInitializers; - public LazyObjectOrCollectionInitializerExpression(Lazy> initializers, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public LazyObjectOrCollectionInitializerExpression(Lazy> initializers, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyInitializers = initializers ?? throw new System.ArgumentNullException(nameof(initializers)); } @@ -5501,8 +5501,8 @@ internal sealed partial class LazyObjectOrCollectionInitializerExpression : Base /// internal abstract partial class BaseMemberInitializerExpression : Operation, IMemberInitializerExpression { - protected BaseMemberInitializerExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.MemberInitializerExpression, semanticModel, syntax, type, constantValue) + protected BaseMemberInitializerExpression(SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.MemberInitializerExpression, semanticModel, syntax, type, constantValue, isImplicit) { } @@ -5540,8 +5540,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class MemberInitializerExpression : BaseMemberInitializerExpression, IMemberInitializerExpression { - public MemberInitializerExpression(IMemberReferenceExpression initializedMember, IObjectOrCollectionInitializerExpression initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public MemberInitializerExpression(IMemberReferenceExpression initializedMember, IObjectOrCollectionInitializerExpression initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { InitializedMemberImpl = initializedMember; InitializerImpl = initializer; @@ -5559,8 +5559,8 @@ internal sealed partial class LazyMemberInitializerExpression : BaseMemberInitia private readonly Lazy _lazyInitializedMember; private readonly Lazy _lazyInitializer; - public LazyMemberInitializerExpression(Lazy initializedMember, Lazy initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(semanticModel, syntax, type, constantValue) + public LazyMemberInitializerExpression(Lazy initializedMember, Lazy initializer, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(semanticModel, syntax, type, constantValue, isImplicit) { _lazyInitializedMember = initializedMember ?? throw new System.ArgumentNullException(nameof(initializedMember)); _lazyInitializer = initializer ?? throw new System.ArgumentNullException(nameof(initializer)); @@ -5576,8 +5576,8 @@ internal sealed partial class LazyMemberInitializerExpression : BaseMemberInitia /// internal abstract partial class BaseCollectionElementInitializerExpression : Operation, ICollectionElementInitializerExpression { - protected BaseCollectionElementInitializerExpression(IMethodSymbol addMethod, bool isDynamic, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(OperationKind.CollectionElementInitializerExpression, semanticModel, syntax, type, constantValue) + protected BaseCollectionElementInitializerExpression(IMethodSymbol addMethod, bool isDynamic, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(OperationKind.CollectionElementInitializerExpression, semanticModel, syntax, type, constantValue, isImplicit) { AddMethod = addMethod; IsDynamic = isDynamic; @@ -5620,8 +5620,8 @@ public override void Accept(OperationVisitor visitor) /// internal sealed partial class CollectionElementInitializerExpression : BaseCollectionElementInitializerExpression, ICollectionElementInitializerExpression { - public CollectionElementInitializerExpression(IMethodSymbol addMethod, ImmutableArray arguments, bool isDynamic, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(addMethod, isDynamic, semanticModel, syntax, type, constantValue) + public CollectionElementInitializerExpression(IMethodSymbol addMethod, ImmutableArray arguments, bool isDynamic, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(addMethod, isDynamic, semanticModel, syntax, type, constantValue, isImplicit) { ArgumentsImpl = arguments; } @@ -5636,8 +5636,8 @@ internal sealed partial class LazyCollectionElementInitializerExpression : BaseC { private readonly Lazy> _lazyArguments; - public LazyCollectionElementInitializerExpression(IMethodSymbol addMethod, Lazy> arguments, bool isDynamic, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) : - base(addMethod, isDynamic, semanticModel, syntax, type, constantValue) + public LazyCollectionElementInitializerExpression(IMethodSymbol addMethod, Lazy> arguments, bool isDynamic, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) : + base(addMethod, isDynamic, semanticModel, syntax, type, constantValue, isImplicit) { _lazyArguments = arguments ?? throw new System.ArgumentNullException(nameof(arguments)); } diff --git a/src/Compilers/Core/Portable/Operations/IOperation.cs b/src/Compilers/Core/Portable/Operations/IOperation.cs index 494ba5cf69fbe0c031b2c6ea07cc7ae021741bdd..b979b2749c9d74dd076faf00ef31829510662623 100644 --- a/src/Compilers/Core/Portable/Operations/IOperation.cs +++ b/src/Compilers/Core/Portable/Operations/IOperation.cs @@ -54,5 +54,10 @@ public interface IOperation void Accept(OperationVisitor visitor); TResult Accept(OperationVisitor visitor, TArgument argument); + + /// + /// Set to True if compiler generated /implicitly computed by compiler code + /// + bool IsImplicit { get; } } } diff --git a/src/Compilers/Core/Portable/Operations/Operation.cs b/src/Compilers/Core/Portable/Operations/Operation.cs index ef00c9d67a7f78165f92cdf8b21511e62995a70b..93a4af4a882826abc41c7774ce51e5d08c853d34 100644 --- a/src/Compilers/Core/Portable/Operations/Operation.cs +++ b/src/Compilers/Core/Portable/Operations/Operation.cs @@ -24,7 +24,7 @@ internal abstract class Operation : IOperation // but once initialized, will never change private IOperation _parentDoNotAccessDirectly; - public Operation(OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue) + public Operation(OperationKind kind, SemanticModel semanticModel, SyntaxNode syntax, ITypeSymbol type, Optional constantValue, bool isImplicit) { SemanticModel = semanticModel; @@ -32,6 +32,7 @@ public Operation(OperationKind kind, SemanticModel semanticModel, SyntaxNode syn Syntax = syntax; Type = type; ConstantValue = constantValue; + IsImplicit = isImplicit; } /// @@ -50,6 +51,11 @@ public IOperation Parent } } + /// + /// Set to True if compiler generated /implicitly computed by compiler code + /// + public bool IsImplicit { get; } + /// /// Identifies the kind of the operation. /// @@ -104,9 +110,9 @@ protected void SetParentOperation(IOperation parent) /// /// Use this to create IOperation when we don't have proper specific IOperation yet for given language construct /// - public static IOperation CreateOperationNone(SemanticModel semanticModel, SyntaxNode node, Optional constantValue, Func> getChildren) + public static IOperation CreateOperationNone(SemanticModel semanticModel, SyntaxNode node, Optional constantValue, Func> getChildren, bool isImplicit) { - return new NoneOperation(semanticModel, node, constantValue, getChildren); + return new NoneOperation(semanticModel, node, constantValue, getChildren, isImplicit); } public static T SetParentOperation(T operation, IOperation parent) where T : IOperation @@ -160,8 +166,8 @@ private class NoneOperation : Operation { private readonly Func> _getChildren; - public NoneOperation(SemanticModel semanticModel, SyntaxNode node, Optional constantValue, Func> getChildren) : - base(OperationKind.None, semanticModel, node, type: null, constantValue: constantValue) + public NoneOperation(SemanticModel semanticModel, SyntaxNode node, Optional constantValue, Func> getChildren, bool isImplicit) : + base(OperationKind.None, semanticModel, node, type: null, constantValue: constantValue, isImplicit: isImplicit) { _getChildren = getChildren; } diff --git a/src/Compilers/Core/Portable/Operations/OperationCloner.cs b/src/Compilers/Core/Portable/Operations/OperationCloner.cs index b443c0a9f0b5c8dc2338006fedd7b0c5c2e2c436..70b85d69ef07d6a8cfafaea95e83eb24618d27ad 100644 --- a/src/Compilers/Core/Portable/Operations/OperationCloner.cs +++ b/src/Compilers/Core/Portable/Operations/OperationCloner.cs @@ -25,7 +25,7 @@ public override IOperation DefaultVisit(IOperation operation, object argument) internal override IOperation VisitNoneOperation(IOperation operation, object argument) { - return Operation.CreateOperationNone(((Operation)operation).SemanticModel, operation.Syntax, operation.ConstantValue, () => VisitArray(operation.Children.ToImmutableArray())); + return Operation.CreateOperationNone(((Operation)operation).SemanticModel, operation.Syntax, operation.ConstantValue, () => VisitArray(operation.Children.ToImmutableArray()), operation.IsImplicit); } private ImmutableArray VisitArray(ImmutableArray nodes) where T : IOperation @@ -36,437 +36,437 @@ internal override IOperation VisitNoneOperation(IOperation operation, object arg public override IOperation VisitBlockStatement(IBlockStatement operation, object argument) { - return new BlockStatement(VisitArray(operation.Statements), operation.Locals, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new BlockStatement(VisitArray(operation.Statements), operation.Locals, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitVariableDeclarationStatement(IVariableDeclarationStatement operation, object argument) { - return new VariableDeclarationStatement(VisitArray(operation.Declarations), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new VariableDeclarationStatement(VisitArray(operation.Declarations), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitVariableDeclaration(IVariableDeclaration operation, object argument) { - return new VariableDeclaration(operation.Variables, Visit(operation.Initializer), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new VariableDeclaration(operation.Variables, Visit(operation.Initializer), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitSwitchStatement(ISwitchStatement operation, object argument) { - return new SwitchStatement(Visit(operation.Value), VisitArray(operation.Cases), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new SwitchStatement(Visit(operation.Value), VisitArray(operation.Cases), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitSwitchCase(ISwitchCase operation, object argument) { - return new SwitchCase(VisitArray(operation.Clauses), VisitArray(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new SwitchCase(VisitArray(operation.Clauses), VisitArray(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitSingleValueCaseClause(ISingleValueCaseClause operation, object argument) { - return new SingleValueCaseClause(Visit(operation.Value), operation.Equality, operation.CaseKind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new SingleValueCaseClause(Visit(operation.Value), operation.Equality, operation.CaseKind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitRelationalCaseClause(IRelationalCaseClause operation, object argument) { - return new RelationalCaseClause(Visit(operation.Value), operation.Relation, operation.CaseKind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new RelationalCaseClause(Visit(operation.Value), operation.Relation, operation.CaseKind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitRangeCaseClause(IRangeCaseClause operation, object argument) { - return new RangeCaseClause(Visit(operation.MinimumValue), Visit(operation.MaximumValue), operation.CaseKind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new RangeCaseClause(Visit(operation.MinimumValue), Visit(operation.MaximumValue), operation.CaseKind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitDefaultCaseClause(IDefaultCaseClause operation, object argument) { - return new DefaultCaseClause(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new DefaultCaseClause(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitIfStatement(IIfStatement operation, object argument) { - return new IfStatement(Visit(operation.Condition), Visit(operation.IfTrueStatement), Visit(operation.IfFalseStatement), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new IfStatement(Visit(operation.Condition), Visit(operation.IfTrueStatement), Visit(operation.IfFalseStatement), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitWhileUntilLoopStatement(IWhileUntilLoopStatement operation, object argument) { - return new WhileUntilLoopStatement(operation.IsTopTest, operation.IsWhile, Visit(operation.Condition), operation.LoopKind, Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new WhileUntilLoopStatement(operation.IsTopTest, operation.IsWhile, Visit(operation.Condition), operation.LoopKind, Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitForLoopStatement(IForLoopStatement operation, object argument) { - return new ForLoopStatement(VisitArray(operation.Before), VisitArray(operation.AtLoopBottom), operation.Locals, Visit(operation.Condition), operation.LoopKind, Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ForLoopStatement(VisitArray(operation.Before), VisitArray(operation.AtLoopBottom), operation.Locals, Visit(operation.Condition), operation.LoopKind, Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitForEachLoopStatement(IForEachLoopStatement operation, object argument) { - return new ForEachLoopStatement(operation.IterationVariable, Visit(operation.Collection), operation.LoopKind, Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ForEachLoopStatement(operation.IterationVariable, Visit(operation.Collection), operation.LoopKind, Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitLabeledStatement(ILabeledStatement operation, object argument) { - return new LabeledStatement(operation.Label, Visit(operation.Statement), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new LabeledStatement(operation.Label, Visit(operation.Statement), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitBranchStatement(IBranchStatement operation, object argument) { - return new BranchStatement(operation.Target, operation.BranchKind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new BranchStatement(operation.Target, operation.BranchKind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitYieldBreakStatement(IReturnStatement operation, object argument) { - return new ReturnStatement(operation.Kind, Visit(operation.ReturnedValue), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ReturnStatement(operation.Kind, Visit(operation.ReturnedValue), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitEmptyStatement(IEmptyStatement operation, object argument) { - return new EmptyStatement(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new EmptyStatement(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitThrowStatement(IThrowStatement operation, object argument) { - return new ThrowStatement(Visit(operation.ThrownObject), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ThrowStatement(Visit(operation.ThrownObject), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitReturnStatement(IReturnStatement operation, object argument) { - return new ReturnStatement(operation.Kind, Visit(operation.ReturnedValue), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ReturnStatement(operation.Kind, Visit(operation.ReturnedValue), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitLockStatement(ILockStatement operation, object argument) { - return new LockStatement(Visit(operation.LockedObject), Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new LockStatement(Visit(operation.LockedObject), Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitTryStatement(ITryStatement operation, object argument) { - return new TryStatement(Visit(operation.Body), VisitArray(operation.Catches), Visit(operation.FinallyHandler), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new TryStatement(Visit(operation.Body), VisitArray(operation.Catches), Visit(operation.FinallyHandler), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitCatchClause(ICatchClause operation, object argument) { - return new CatchClause(Visit(operation.Handler), operation.CaughtType, Visit(operation.Filter), operation.ExceptionLocal, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new CatchClause(Visit(operation.Handler), operation.CaughtType, Visit(operation.Filter), operation.ExceptionLocal, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitUsingStatement(IUsingStatement operation, object argument) { - return new UsingStatement(Visit(operation.Body), Visit(operation.Declaration), Visit(operation.Value), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new UsingStatement(Visit(operation.Body), Visit(operation.Declaration), Visit(operation.Value), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitFixedStatement(IFixedStatement operation, object argument) { - return new FixedStatement(Visit(operation.Variables), Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new FixedStatement(Visit(operation.Variables), Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitExpressionStatement(IExpressionStatement operation, object argument) { - return new ExpressionStatement(Visit(operation.Expression), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ExpressionStatement(Visit(operation.Expression), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitWithStatement(IWithStatement operation, object argument) { - return new WithStatement(Visit(operation.Body), Visit(operation.Value), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new WithStatement(Visit(operation.Body), Visit(operation.Value), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitStopStatement(IStopStatement operation, object argument) { - return new StopStatement(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new StopStatement(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitEndStatement(IEndStatement operation, object argument) { - return new EndStatement(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new EndStatement(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitInvocationExpression(IInvocationExpression operation, object argument) { - return new InvocationExpression(operation.TargetMethod, Visit(operation.Instance), operation.IsVirtual, VisitArray(operation.ArgumentsInEvaluationOrder), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new InvocationExpression(operation.TargetMethod, Visit(operation.Instance), operation.IsVirtual, VisitArray(operation.ArgumentsInEvaluationOrder), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitArgument(IArgument operation, object argument) { - return new Argument(operation.ArgumentKind, operation.Parameter, Visit(operation.Value), Visit(operation.InConversion), Visit(operation.OutConversion), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new Argument(operation.ArgumentKind, operation.Parameter, Visit(operation.Value), Visit(operation.InConversion), Visit(operation.OutConversion), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitOmittedArgumentExpression(IOmittedArgumentExpression operation, object argument) { - return new OmittedArgumentExpression(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new OmittedArgumentExpression(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitArrayElementReferenceExpression(IArrayElementReferenceExpression operation, object argument) { - return new ArrayElementReferenceExpression(Visit(operation.ArrayReference), VisitArray(operation.Indices), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ArrayElementReferenceExpression(Visit(operation.ArrayReference), VisitArray(operation.Indices), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitPointerIndirectionReferenceExpression(IPointerIndirectionReferenceExpression operation, object argument) { - return new PointerIndirectionReferenceExpression(Visit(operation.Pointer), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new PointerIndirectionReferenceExpression(Visit(operation.Pointer), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitLocalReferenceExpression(ILocalReferenceExpression operation, object argument) { - return new LocalReferenceExpression(operation.Local, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new LocalReferenceExpression(operation.Local, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitParameterReferenceExpression(IParameterReferenceExpression operation, object argument) { - return new ParameterReferenceExpression(operation.Parameter, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ParameterReferenceExpression(operation.Parameter, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitSyntheticLocalReferenceExpression(ISyntheticLocalReferenceExpression operation, object argument) { - return new SyntheticLocalReferenceExpression(operation.SyntheticLocalKind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new SyntheticLocalReferenceExpression(operation.SyntheticLocalKind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitInstanceReferenceExpression(IInstanceReferenceExpression operation, object argument) { - return new InstanceReferenceExpression(operation.InstanceReferenceKind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new InstanceReferenceExpression(operation.InstanceReferenceKind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitFieldReferenceExpression(IFieldReferenceExpression operation, object argument) { - return new FieldReferenceExpression(operation.Field, Visit(operation.Instance), operation.Member, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new FieldReferenceExpression(operation.Field, Visit(operation.Instance), operation.Member, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitMethodBindingExpression(IMethodBindingExpression operation, object argument) { - return new MethodBindingExpression(operation.Method, operation.IsVirtual, Visit(operation.Instance), operation.Member, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new MethodBindingExpression(operation.Method, operation.IsVirtual, Visit(operation.Instance), operation.Member, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitPropertyReferenceExpression(IPropertyReferenceExpression operation, object argument) { - return new PropertyReferenceExpression(operation.Property, Visit(operation.Instance), operation.Member, VisitArray(operation.ArgumentsInEvaluationOrder), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new PropertyReferenceExpression(operation.Property, Visit(operation.Instance), operation.Member, VisitArray(operation.ArgumentsInEvaluationOrder), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitEventReferenceExpression(IEventReferenceExpression operation, object argument) { - return new EventReferenceExpression(operation.Event, Visit(operation.Instance), operation.Member, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new EventReferenceExpression(operation.Event, Visit(operation.Instance), operation.Member, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitEventAssignmentExpression(IEventAssignmentExpression operation, object argument) { - return new EventAssignmentExpression(Visit(operation.EventReference), Visit(operation.HandlerValue), operation.Adds, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new EventAssignmentExpression(Visit(operation.EventReference), Visit(operation.HandlerValue), operation.Adds, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitConditionalAccessExpression(IConditionalAccessExpression operation, object argument) { - return new ConditionalAccessExpression(Visit(operation.ConditionalValue), Visit(operation.ConditionalInstance), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ConditionalAccessExpression(Visit(operation.ConditionalValue), Visit(operation.ConditionalInstance), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitConditionalAccessInstanceExpression(IConditionalAccessInstanceExpression operation, object argument) { - return new ConditionalAccessInstanceExpression(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ConditionalAccessInstanceExpression(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitPlaceholderExpression(IPlaceholderExpression operation, object argument) { - return new PlaceholderExpression(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new PlaceholderExpression(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitUnaryOperatorExpression(IUnaryOperatorExpression operation, object argument) { - return new UnaryOperatorExpression(operation.UnaryOperationKind, Visit(operation.Operand), operation.IsLifted, operation.UsesOperatorMethod, operation.OperatorMethod, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new UnaryOperatorExpression(operation.UnaryOperationKind, Visit(operation.Operand), operation.IsLifted, operation.UsesOperatorMethod, operation.OperatorMethod, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitBinaryOperatorExpression(IBinaryOperatorExpression operation, object argument) { - return new BinaryOperatorExpression(operation.BinaryOperationKind, Visit(operation.LeftOperand), Visit(operation.RightOperand), operation.IsLifted, operation.UsesOperatorMethod, operation.OperatorMethod, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new BinaryOperatorExpression(operation.BinaryOperationKind, Visit(operation.LeftOperand), Visit(operation.RightOperand), operation.IsLifted, operation.UsesOperatorMethod, operation.OperatorMethod, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitConditionalChoiceExpression(IConditionalChoiceExpression operation, object argument) { - return new ConditionalChoiceExpression(Visit(operation.Condition), Visit(operation.IfTrueValue), Visit(operation.IfFalseValue), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ConditionalChoiceExpression(Visit(operation.Condition), Visit(operation.IfTrueValue), Visit(operation.IfFalseValue), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitNullCoalescingExpression(INullCoalescingExpression operation, object argument) { - return new NullCoalescingExpression(Visit(operation.PrimaryOperand), Visit(operation.SecondaryOperand), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new NullCoalescingExpression(Visit(operation.PrimaryOperand), Visit(operation.SecondaryOperand), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitIsTypeExpression(IIsTypeExpression operation, object argument) { - return new IsTypeExpression(Visit(operation.Operand), operation.IsType, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new IsTypeExpression(Visit(operation.Operand), operation.IsType, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitSizeOfExpression(ISizeOfExpression operation, object argument) { - return new SizeOfExpression(operation.TypeOperand, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new SizeOfExpression(operation.TypeOperand, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitTypeOfExpression(ITypeOfExpression operation, object argument) { - return new TypeOfExpression(operation.TypeOperand, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new TypeOfExpression(operation.TypeOperand, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitLambdaExpression(ILambdaExpression operation, object argument) { - return new LambdaExpression(operation.Signature, Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new LambdaExpression(operation.Signature, Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitLiteralExpression(ILiteralExpression operation, object argument) { - return new LiteralExpression(operation.Text, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new LiteralExpression(operation.Text, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitAwaitExpression(IAwaitExpression operation, object argument) { - return new AwaitExpression(Visit(operation.AwaitedValue), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new AwaitExpression(Visit(operation.AwaitedValue), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitNameOfExpression(INameOfExpression operation, object argument) { - return new NameOfExpression(Visit(operation.Argument), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new NameOfExpression(Visit(operation.Argument), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitThrowExpression(IThrowExpression operation, object argument) { - return new ThrowExpression(Visit(operation.Expression), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ThrowExpression(Visit(operation.Expression), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitAddressOfExpression(IAddressOfExpression operation, object argument) { - return new AddressOfExpression(Visit(operation.Reference), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new AddressOfExpression(Visit(operation.Reference), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitObjectCreationExpression(IObjectCreationExpression operation, object argument) { - return new ObjectCreationExpression(operation.Constructor, Visit(operation.Initializer), VisitArray(operation.ArgumentsInEvaluationOrder), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ObjectCreationExpression(operation.Constructor, Visit(operation.Initializer), VisitArray(operation.ArgumentsInEvaluationOrder), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitAnonymousObjectCreationExpression(IAnonymousObjectCreationExpression operation, object argument) { - return new AnonymousObjectCreationExpression(VisitArray(operation.Initializers), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new AnonymousObjectCreationExpression(VisitArray(operation.Initializers), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitObjectOrCollectionInitializerExpression(IObjectOrCollectionInitializerExpression operation, object argument) { - return new ObjectOrCollectionInitializerExpression(VisitArray(operation.Initializers), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ObjectOrCollectionInitializerExpression(VisitArray(operation.Initializers), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitMemberInitializerExpression(IMemberInitializerExpression operation, object argument) { - return new MemberInitializerExpression(Visit(operation.InitializedMember), Visit(operation.Initializer), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new MemberInitializerExpression(Visit(operation.InitializedMember), Visit(operation.Initializer), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitCollectionElementInitializerExpression(ICollectionElementInitializerExpression operation, object argument) { - return new CollectionElementInitializerExpression(operation.AddMethod, VisitArray(operation.Arguments), operation.IsDynamic, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new CollectionElementInitializerExpression(operation.AddMethod, VisitArray(operation.Arguments), operation.IsDynamic, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitFieldInitializer(IFieldInitializer operation, object argument) { - return new FieldInitializer(operation.InitializedFields, Visit(operation.Value), operation.Kind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new FieldInitializer(operation.InitializedFields, Visit(operation.Value), operation.Kind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitPropertyInitializer(IPropertyInitializer operation, object argument) { - return new PropertyInitializer(operation.InitializedProperty, Visit(operation.Value), operation.Kind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new PropertyInitializer(operation.InitializedProperty, Visit(operation.Value), operation.Kind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitParameterInitializer(IParameterInitializer operation, object argument) { - return new ParameterInitializer(operation.Parameter, Visit(operation.Value), operation.Kind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ParameterInitializer(operation.Parameter, Visit(operation.Value), operation.Kind, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitArrayCreationExpression(IArrayCreationExpression operation, object argument) { - return new ArrayCreationExpression(operation.ElementType, VisitArray(operation.DimensionSizes), Visit(operation.Initializer), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ArrayCreationExpression(operation.ElementType, VisitArray(operation.DimensionSizes), Visit(operation.Initializer), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitArrayInitializer(IArrayInitializer operation, object argument) { - return new ArrayInitializer(VisitArray(operation.ElementValues), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ArrayInitializer(VisitArray(operation.ElementValues), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitSimpleAssignmentExpression(ISimpleAssignmentExpression operation, object argument) { - return new SimpleAssignmentExpression(Visit(operation.Target), Visit(operation.Value), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new SimpleAssignmentExpression(Visit(operation.Target), Visit(operation.Value), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitCompoundAssignmentExpression(ICompoundAssignmentExpression operation, object argument) { - return new CompoundAssignmentExpression(operation.BinaryOperationKind, operation.IsLifted, Visit(operation.Target), Visit(operation.Value), operation.UsesOperatorMethod, operation.OperatorMethod, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new CompoundAssignmentExpression(operation.BinaryOperationKind, operation.IsLifted, Visit(operation.Target), Visit(operation.Value), operation.UsesOperatorMethod, operation.OperatorMethod, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitIncrementExpression(IIncrementExpression operation, object argument) { - return new IncrementExpression(operation.IncrementOperationKind, Visit(operation.Target), operation.UsesOperatorMethod, operation.OperatorMethod, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new IncrementExpression(operation.IncrementOperationKind, Visit(operation.Target), operation.UsesOperatorMethod, operation.OperatorMethod, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitParenthesizedExpression(IParenthesizedExpression operation, object argument) { - return new ParenthesizedExpression(Visit(operation.Operand), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ParenthesizedExpression(Visit(operation.Operand), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitDynamicMemberReferenceExpression(IDynamicMemberReferenceExpression operation, object argument) { - return new DynamicMemberReferenceExpression(Visit(operation.Instance), operation.MemberName, operation.TypeArguments, operation.ContainingType, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new DynamicMemberReferenceExpression(Visit(operation.Instance), operation.MemberName, operation.TypeArguments, operation.ContainingType, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitDynamicObjectCreationExpression(IDynamicObjectCreationExpression operation, object argument) { - return new DynamicObjectCreationExpression(operation.Name, operation.ApplicableSymbols, VisitArray(operation.Arguments), operation.ArgumentNames, operation.ArgumentRefKinds, Visit(operation.Initializer), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new DynamicObjectCreationExpression(operation.Name, operation.ApplicableSymbols, VisitArray(operation.Arguments), operation.ArgumentNames, operation.ArgumentRefKinds, Visit(operation.Initializer), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitDefaultValueExpression(IDefaultValueExpression operation, object argument) { - return new DefaultValueExpression(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new DefaultValueExpression(((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitTypeParameterObjectCreationExpression(ITypeParameterObjectCreationExpression operation, object argument) { - return new TypeParameterObjectCreationExpression(Visit(operation.Initializer), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new TypeParameterObjectCreationExpression(Visit(operation.Initializer), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitInvalidStatement(IInvalidStatement operation, object argument) { - return new InvalidStatement(VisitArray(operation.Children.ToImmutableArray()), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new InvalidStatement(VisitArray(operation.Children.ToImmutableArray()), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitInvalidExpression(IInvalidExpression operation, object argument) { - return new InvalidExpression(VisitArray(operation.Children.ToImmutableArray()), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new InvalidExpression(VisitArray(operation.Children.ToImmutableArray()), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitLocalFunctionStatement(ILocalFunctionStatement operation, object argument) { - return new LocalFunctionStatement(operation.LocalFunctionSymbol, Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new LocalFunctionStatement(operation.LocalFunctionSymbol, Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitInterpolatedStringExpression(IInterpolatedStringExpression operation, object argument) { - return new InterpolatedStringExpression(VisitArray(operation.Parts), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new InterpolatedStringExpression(VisitArray(operation.Parts), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitInterpolatedStringText(IInterpolatedStringText operation, object argument) { - return new InterpolatedStringText(Visit(operation.Text), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new InterpolatedStringText(Visit(operation.Text), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitInterpolation(IInterpolation operation, object argument) { - return new Interpolation(Visit(operation.Expression), Visit(operation.Alignment), Visit(operation.FormatString), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new Interpolation(Visit(operation.Expression), Visit(operation.Alignment), Visit(operation.FormatString), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitIsPatternExpression(IIsPatternExpression operation, object argument) { - return new IsPatternExpression(Visit(operation.Expression), Visit(operation.Pattern), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new IsPatternExpression(Visit(operation.Expression), Visit(operation.Pattern), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitConstantPattern(IConstantPattern operation, object argument) { - return new ConstantPattern(Visit(operation.Value), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new ConstantPattern(Visit(operation.Value), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitDeclarationPattern(IDeclarationPattern operation, object argument) { - return new DeclarationPattern(operation.DeclaredSymbol, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new DeclarationPattern(operation.DeclaredSymbol, ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitPatternCaseClause(IPatternCaseClause operation, object argument) { - return new PatternCaseClause(operation.Label, Visit(operation.Pattern), Visit(operation.GuardExpression), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new PatternCaseClause(operation.Label, Visit(operation.Pattern), Visit(operation.GuardExpression), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } public override IOperation VisitTupleExpression(ITupleExpression operation, object argument) { - return new TupleExpression(VisitArray(operation.Elements), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue); + return new TupleExpression(VisitArray(operation.Elements), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit); } } } diff --git a/src/Compilers/Core/Portable/Operations/OperationFactory.cs b/src/Compilers/Core/Portable/Operations/OperationFactory.cs index 5f1b7b8cc2d4624c50889f846e33bf1017b000d1..9be28f1fe03743d3d3cea605dd054c3f8bb68bf5 100644 --- a/src/Compilers/Core/Portable/Operations/OperationFactory.cs +++ b/src/Compilers/Core/Portable/Operations/OperationFactory.cs @@ -20,10 +20,11 @@ public static VariableDeclaration CreateVariableDeclaration(ImmutableArray)); + constantValue: default(Optional), + isImplicit: false); // variable declaration is always explicit } - public static IConditionalChoiceExpression CreateConditionalChoiceExpression(IOperation condition, IOperation ifTrue, IOperation ifFalse, ITypeSymbol resultType, SemanticModel semanticModel, SyntaxNode syntax) + public static IConditionalChoiceExpression CreateConditionalChoiceExpression(IOperation condition, IOperation ifTrue, IOperation ifFalse, ITypeSymbol resultType, SemanticModel semanticModel, SyntaxNode syntax, bool isImplicit) { return new ConditionalChoiceExpression( condition, @@ -32,17 +33,18 @@ public static IConditionalChoiceExpression CreateConditionalChoiceExpression(IOp semanticModel, syntax, resultType, - default(Optional)); + default(Optional), + isImplicit); } - public static IExpressionStatement CreateSimpleAssignmentExpressionStatement(IOperation target, IOperation value, SemanticModel semanticModel, SyntaxNode syntax) + public static IExpressionStatement CreateSimpleAssignmentExpressionStatement(IOperation target, IOperation value, SemanticModel semanticModel, SyntaxNode syntax, bool isImplicit) { - var expression = new SimpleAssignmentExpression(target, value, semanticModel, syntax, target.Type, default(Optional)); - return new ExpressionStatement(expression, semanticModel, syntax, type: null, constantValue: default(Optional)); + var expression = new SimpleAssignmentExpression(target, value, semanticModel, syntax, target.Type, default(Optional), isImplicit); + return new ExpressionStatement(expression, semanticModel, syntax, type: null, constantValue: default(Optional), isImplicit: isImplicit); } public static IExpressionStatement CreateCompoundAssignmentExpressionStatement( - IOperation target, IOperation value, BinaryOperationKind binaryOperationKind, bool isLifted, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax) + IOperation target, IOperation value, BinaryOperationKind binaryOperationKind, bool isLifted, IMethodSymbol operatorMethod, SemanticModel semanticModel, SyntaxNode syntax, bool isImplicit) { var expression = new CompoundAssignmentExpression( binaryOperationKind, @@ -54,52 +56,54 @@ public static IExpressionStatement CreateSimpleAssignmentExpressionStatement(IOp semanticModel, syntax, target.Type, - default(Optional)); + default(Optional), + isImplicit); - return new ExpressionStatement(expression, semanticModel, syntax, type: null, constantValue: default(Optional)); + return new ExpressionStatement(expression, semanticModel, syntax, type: null, constantValue: default(Optional), isImplicit: isImplicit); } - public static ILiteralExpression CreateLiteralExpression(long value, ITypeSymbol resultType, SemanticModel semanticModel, SyntaxNode syntax) + public static ILiteralExpression CreateLiteralExpression(long value, ITypeSymbol resultType, SemanticModel semanticModel, SyntaxNode syntax, bool isImplicit) { - return new LiteralExpression(value.ToString(), semanticModel, syntax, resultType, constantValue: new Optional(value)); + return new LiteralExpression(value.ToString(), semanticModel, syntax, resultType, constantValue: new Optional(value), isImplicit: isImplicit); } - public static ILiteralExpression CreateLiteralExpression(ConstantValue value, ITypeSymbol resultType, SemanticModel semanticModel, SyntaxNode syntax) + public static ILiteralExpression CreateLiteralExpression(ConstantValue value, ITypeSymbol resultType, SemanticModel semanticModel, SyntaxNode syntax, bool isImplicit) { - return new LiteralExpression(value.GetValueToDisplay(), semanticModel, syntax, resultType, new Optional(value.Value)); + return new LiteralExpression(value.GetValueToDisplay(), semanticModel, syntax, resultType, new Optional(value.Value), isImplicit); } public static IBinaryOperatorExpression CreateBinaryOperatorExpression( - BinaryOperationKind binaryOperationKind, IOperation left, IOperation right, ITypeSymbol resultType, SemanticModel semanticModel, SyntaxNode syntax, bool isLifted) + BinaryOperationKind binaryOperationKind, IOperation left, IOperation right, ITypeSymbol resultType, SemanticModel semanticModel, SyntaxNode syntax, bool isLifted, bool isImplicit) { return new BinaryOperatorExpression( binaryOperationKind, left, right, isLifted: isLifted, usesOperatorMethod: false, operatorMethod: null, - semanticModel: semanticModel, syntax: syntax, type: resultType, constantValue: default); + semanticModel: semanticModel, syntax: syntax, type: resultType, constantValue: default, isImplicit: isImplicit); } public static IArrayCreationExpression CreateArrayCreationExpression( - IArrayTypeSymbol arrayType, ImmutableArray elementValues, SemanticModel semanticModel, SyntaxNode syntax) + IArrayTypeSymbol arrayType, ImmutableArray elementValues, SemanticModel semanticModel, SyntaxNode syntax, bool isImplicit) { - var initializer = new ArrayInitializer(elementValues, semanticModel, syntax, arrayType, default(Optional)); + var initializer = new ArrayInitializer(elementValues, semanticModel, syntax, arrayType, default(Optional), isImplicit); return new ArrayCreationExpression( arrayType.ElementType, - ImmutableArray.Create(CreateLiteralExpression(elementValues.Count(), resultType: null, semanticModel: semanticModel, syntax: syntax)), + ImmutableArray.Create(CreateLiteralExpression(elementValues.Count(), resultType: null, semanticModel: semanticModel, syntax: syntax, isImplicit: isImplicit)), initializer, semanticModel, syntax, arrayType, - default(Optional)); + default(Optional), + isImplicit); } - public static IInvalidExpression CreateInvalidExpression(SemanticModel semanticModel, SyntaxNode syntax) + public static IInvalidExpression CreateInvalidExpression(SemanticModel semanticModel, SyntaxNode syntax, bool isImplicit) { - return CreateInvalidExpression(semanticModel, syntax, ImmutableArray.Empty); + return CreateInvalidExpression(semanticModel, syntax, ImmutableArray.Empty, isImplicit); } - public static IInvalidExpression CreateInvalidExpression(SemanticModel semanticModel, SyntaxNode syntax, ImmutableArray children) + public static IInvalidExpression CreateInvalidExpression(SemanticModel semanticModel, SyntaxNode syntax, ImmutableArray children, bool isImplicit) { - return new InvalidExpression(children, semanticModel, syntax, type: null, constantValue: default(Optional)); + return new InvalidExpression(children, semanticModel, syntax, type: null, constantValue: default(Optional), isImplicit: isImplicit); } } } diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt index d296b1dba48e72c25f9d6b0eab54cf969310f5b6..092263a1b36ce48d9e49590c1a281447520c7bf4 100644 --- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt +++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt @@ -1,7 +1,6 @@ *REMOVED*Microsoft.CodeAnalysis.Compilation.Emit(System.IO.Stream peStream, System.IO.Stream pdbStream = null, System.IO.Stream xmlDocumentationStream = null, System.IO.Stream win32Resources = null, System.Collections.Generic.IEnumerable manifestResources = null, Microsoft.CodeAnalysis.Emit.EmitOptions options = null, Microsoft.CodeAnalysis.IMethodSymbol debugEntryPoint = null, System.IO.Stream sourceLinkStream = null, System.Collections.Generic.IEnumerable embeddedTexts = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.Emit.EmitResult *REMOVED*Microsoft.CodeAnalysis.Emit.EmitOptions.EmitOptions(bool metadataOnly = false, Microsoft.CodeAnalysis.Emit.DebugInformationFormat debugInformationFormat = (Microsoft.CodeAnalysis.Emit.DebugInformationFormat)0, string pdbFilePath = null, string outputNameOverride = null, int fileAlignment = 0, ulong baseAddress = 0, bool highEntropyVirtualAddressSpace = false, Microsoft.CodeAnalysis.SubsystemVersion subsystemVersion = default(Microsoft.CodeAnalysis.SubsystemVersion), string runtimeMetadataVersion = null, bool tolerateErrors = false, bool includePrivateMembers = false, System.Collections.Immutable.ImmutableArray instrumentationKinds = default(System.Collections.Immutable.ImmutableArray)) -> void *REMOVED*Microsoft.CodeAnalysis.IOperation.IsInvalid.get -> bool -abstract Microsoft.CodeAnalysis.SemanticModel.RootCore.get -> Microsoft.CodeAnalysis.SyntaxNode Microsoft.CodeAnalysis.CommandLineArguments.DisplayLangVersions.get -> bool Microsoft.CodeAnalysis.Diagnostics.AnalysisContext.RegisterOperationAction(System.Action action, params Microsoft.CodeAnalysis.OperationKind[] operationKinds) -> void Microsoft.CodeAnalysis.Diagnostics.CompilationStartAnalysisContext.RegisterOperationAction(System.Action action, params Microsoft.CodeAnalysis.OperationKind[] operationKinds) -> void @@ -42,11 +41,12 @@ Microsoft.CodeAnalysis.IOperation.Accept(Microsoft.CodeAnalysis.Semantics.Operat Microsoft.CodeAnalysis.IOperation.Accept(Microsoft.CodeAnalysis.Semantics.OperationVisitor visitor, TArgument argument) -> TResult Microsoft.CodeAnalysis.IOperation.Children.get -> System.Collections.Generic.IEnumerable Microsoft.CodeAnalysis.IOperation.ConstantValue.get -> Microsoft.CodeAnalysis.Optional +Microsoft.CodeAnalysis.IOperation.IsImplicit.get -> bool Microsoft.CodeAnalysis.IOperation.Kind.get -> Microsoft.CodeAnalysis.OperationKind Microsoft.CodeAnalysis.IOperation.Language.get -> string +Microsoft.CodeAnalysis.IOperation.Parent.get -> Microsoft.CodeAnalysis.IOperation 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 @@ -69,8 +69,8 @@ Microsoft.CodeAnalysis.OperationKind.ConversionExpression = 258 -> Microsoft.Cod Microsoft.CodeAnalysis.OperationKind.DeclarationPattern = 1040 -> Microsoft.CodeAnalysis.OperationKind Microsoft.CodeAnalysis.OperationKind.DefaultCaseClause = 1042 -> Microsoft.CodeAnalysis.OperationKind Microsoft.CodeAnalysis.OperationKind.DefaultValueExpression = 512 -> Microsoft.CodeAnalysis.OperationKind -Microsoft.CodeAnalysis.OperationKind.DynamicObjectCreationExpression = 293 -> Microsoft.CodeAnalysis.OperationKind Microsoft.CodeAnalysis.OperationKind.DynamicMemberReferenceExpression = 294 -> Microsoft.CodeAnalysis.OperationKind +Microsoft.CodeAnalysis.OperationKind.DynamicObjectCreationExpression = 293 -> Microsoft.CodeAnalysis.OperationKind Microsoft.CodeAnalysis.OperationKind.EmptyStatement = 9 -> Microsoft.CodeAnalysis.OperationKind Microsoft.CodeAnalysis.OperationKind.EndStatement = 81 -> Microsoft.CodeAnalysis.OperationKind Microsoft.CodeAnalysis.OperationKind.EventAssignmentExpression = 283 -> Microsoft.CodeAnalysis.OperationKind @@ -365,9 +365,9 @@ Microsoft.CodeAnalysis.Semantics.IAwaitExpression Microsoft.CodeAnalysis.Semantics.IAwaitExpression.AwaitedValue.get -> Microsoft.CodeAnalysis.IOperation Microsoft.CodeAnalysis.Semantics.IBinaryOperatorExpression Microsoft.CodeAnalysis.Semantics.IBinaryOperatorExpression.BinaryOperationKind.get -> Microsoft.CodeAnalysis.Semantics.BinaryOperationKind +Microsoft.CodeAnalysis.Semantics.IBinaryOperatorExpression.IsLifted.get -> bool Microsoft.CodeAnalysis.Semantics.IBinaryOperatorExpression.LeftOperand.get -> Microsoft.CodeAnalysis.IOperation Microsoft.CodeAnalysis.Semantics.IBinaryOperatorExpression.RightOperand.get -> Microsoft.CodeAnalysis.IOperation -Microsoft.CodeAnalysis.Semantics.IBinaryOperatorExpression.IsLifted.get -> bool Microsoft.CodeAnalysis.Semantics.IBlockStatement Microsoft.CodeAnalysis.Semantics.IBlockStatement.Locals.get -> System.Collections.Immutable.ImmutableArray Microsoft.CodeAnalysis.Semantics.IBlockStatement.Statements.get -> System.Collections.Immutable.ImmutableArray @@ -579,9 +579,9 @@ Microsoft.CodeAnalysis.Semantics.ITypeOperationExpression.TypeOperand.get -> Mic Microsoft.CodeAnalysis.Semantics.ITypeParameterObjectCreationExpression Microsoft.CodeAnalysis.Semantics.ITypeParameterObjectCreationExpression.Initializer.get -> Microsoft.CodeAnalysis.Semantics.IObjectOrCollectionInitializerExpression Microsoft.CodeAnalysis.Semantics.IUnaryOperatorExpression +Microsoft.CodeAnalysis.Semantics.IUnaryOperatorExpression.IsLifted.get -> bool Microsoft.CodeAnalysis.Semantics.IUnaryOperatorExpression.Operand.get -> Microsoft.CodeAnalysis.IOperation Microsoft.CodeAnalysis.Semantics.IUnaryOperatorExpression.UnaryOperationKind.get -> Microsoft.CodeAnalysis.Semantics.UnaryOperationKind -Microsoft.CodeAnalysis.Semantics.IUnaryOperatorExpression.IsLifted.get -> bool Microsoft.CodeAnalysis.Semantics.IUsingStatement Microsoft.CodeAnalysis.Semantics.IUsingStatement.Body.get -> Microsoft.CodeAnalysis.IOperation Microsoft.CodeAnalysis.Semantics.IUsingStatement.Declaration.get -> Microsoft.CodeAnalysis.Semantics.IVariableDeclarationStatement @@ -746,6 +746,7 @@ Microsoft.CodeAnalysis.SyntaxTriviaList.SyntaxTriviaList(params Microsoft.CodeAn abstract Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.RegisterOperationAction(System.Action action, System.Collections.Immutable.ImmutableArray operationKinds) -> void abstract Microsoft.CodeAnalysis.Diagnostics.OperationBlockStartAnalysisContext.RegisterOperationBlockEndAction(System.Action action) -> void abstract Microsoft.CodeAnalysis.SemanticModel.GetOperationCore(Microsoft.CodeAnalysis.SyntaxNode node, System.Threading.CancellationToken cancellationToken) -> Microsoft.CodeAnalysis.IOperation +abstract Microsoft.CodeAnalysis.SemanticModel.RootCore.get -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.Optional.ToString() -> string override Microsoft.CodeAnalysis.Semantics.OperationWalker.DefaultVisit(Microsoft.CodeAnalysis.IOperation operation) -> void override Microsoft.CodeAnalysis.Semantics.OperationWalker.Visit(Microsoft.CodeAnalysis.IOperation operation) -> void diff --git a/src/Compilers/VisualBasic/Portable/Binding/Binder_Expressions.vb b/src/Compilers/VisualBasic/Portable/Binding/Binder_Expressions.vb index 0a1bff73558a363483b5da0d1e93ee2e5edc837c..f70f5967e453d2b8494c74490487085a7fcf3a97 100644 --- a/src/Compilers/VisualBasic/Portable/Binding/Binder_Expressions.vb +++ b/src/Compilers/VisualBasic/Portable/Binding/Binder_Expressions.vb @@ -251,11 +251,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic ' e.g. SyntaxKind.MidExpression is handled elsewhere ' NOTE: There were too many "else" cases to justify listing them explicitly and throwing on ' anything unexpected. - ' - ' PROTOTYPE(IOperation) - ' re-enable the assert once this issue is fixed - ' https://github.com/dotnet/roslyn/issues/21180 - ' Debug.Assert(node.ContainsDiagnostics, String.Format("Unexpected {0} syntax does not have diagnostics", node.Kind)) + Debug.Assert(IsSemanticModelBinder OrElse node.ContainsDiagnostics, String.Format("Unexpected {0} syntax does not have diagnostics", node.Kind)) Return BadExpression(node, ImmutableArray(Of BoundExpression).Empty, ErrorTypeSymbol.UnknownResultType) End Select diff --git a/src/Compilers/VisualBasic/Portable/Binding/Binder_Statements.vb b/src/Compilers/VisualBasic/Portable/Binding/Binder_Statements.vb index 9cb0b9308e87b2b1f18df30dec398243ec15fdd3..2eca2a02d2a2270d39fde632606d1da01017a1f4 100644 --- a/src/Compilers/VisualBasic/Portable/Binding/Binder_Statements.vb +++ b/src/Compilers/VisualBasic/Portable/Binding/Binder_Statements.vb @@ -65,11 +65,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic Case SyntaxKind.ElseIfStatement ' ElseIf without a preceding If. - ' - ' PROTOTYPE(IOperation) - ' re-enable the assert once this issue is fixed - ' https://github.com/dotnet/roslyn/issues/21180 - ' Debug.Assert(node.ContainsDiagnostics) + Debug.Assert(IsSemanticModelBinder OrElse node.ContainsDiagnostics) Dim condition = BindBooleanExpression(DirectCast(node, ElseIfStatementSyntax).Condition, diagnostics) Return New BoundBadStatement(node, ImmutableArray.Create(Of BoundNode)(condition), hasErrors:=True) @@ -200,31 +196,27 @@ Namespace Microsoft.CodeAnalysis.VisualBasic ' where only the ones that can appear in a method body have been selected). ' ' We simply need to ignore this, the error is already created by the parser. - ' - ' PROTOTYPE(IOperation) - ' re-enable the assert once this issue is fixed - ' https://github.com/dotnet/roslyn/issues/21180 - 'Debug.Assert(node.ContainsDiagnostics OrElse - ' (node.IsMissing AndAlso - ' (node.Parent.Kind = SyntaxKind.MultiLineSubLambdaExpression OrElse - ' node.Parent.Kind = SyntaxKind.MultiLineFunctionLambdaExpression OrElse - ' node.Parent.Kind = SyntaxKind.AddHandlerAccessorBlock OrElse - ' node.Parent.Kind = SyntaxKind.RemoveHandlerAccessorBlock OrElse - ' node.Parent.Kind = SyntaxKind.RaiseEventAccessorBlock OrElse - ' node.Parent.Kind = SyntaxKind.MultiLineIfBlock OrElse - ' node.Parent.Kind = SyntaxKind.ElseIfBlock OrElse - ' node.Parent.Kind = SyntaxKind.ElseBlock OrElse - ' node.Parent.Kind = SyntaxKind.SimpleDoLoopBlock OrElse - ' node.Parent.Kind = SyntaxKind.DoWhileLoopBlock OrElse - ' node.Parent.Kind = SyntaxKind.DoUntilLoopBlock OrElse - ' node.Parent.Kind = SyntaxKind.WhileBlock OrElse - ' node.Parent.Kind = SyntaxKind.WithBlock OrElse - ' node.Parent.Kind = SyntaxKind.ForBlock OrElse - ' node.Parent.Kind = SyntaxKind.ForEachBlock OrElse - ' node.Parent.Kind = SyntaxKind.SyncLockBlock OrElse - ' node.Parent.Kind = SyntaxKind.SelectBlock OrElse - ' node.Parent.Kind = SyntaxKind.TryBlock OrElse - ' node.Parent.Kind = SyntaxKind.UsingBlock))) + Debug.Assert(IsSemanticModelBinder OrElse node.ContainsDiagnostics OrElse + (node.IsMissing AndAlso + (node.Parent.Kind = SyntaxKind.MultiLineSubLambdaExpression OrElse + node.Parent.Kind = SyntaxKind.MultiLineFunctionLambdaExpression OrElse + node.Parent.Kind = SyntaxKind.AddHandlerAccessorBlock OrElse + node.Parent.Kind = SyntaxKind.RemoveHandlerAccessorBlock OrElse + node.Parent.Kind = SyntaxKind.RaiseEventAccessorBlock OrElse + node.Parent.Kind = SyntaxKind.MultiLineIfBlock OrElse + node.Parent.Kind = SyntaxKind.ElseIfBlock OrElse + node.Parent.Kind = SyntaxKind.ElseBlock OrElse + node.Parent.Kind = SyntaxKind.SimpleDoLoopBlock OrElse + node.Parent.Kind = SyntaxKind.DoWhileLoopBlock OrElse + node.Parent.Kind = SyntaxKind.DoUntilLoopBlock OrElse + node.Parent.Kind = SyntaxKind.WhileBlock OrElse + node.Parent.Kind = SyntaxKind.WithBlock OrElse + node.Parent.Kind = SyntaxKind.ForBlock OrElse + node.Parent.Kind = SyntaxKind.ForEachBlock OrElse + node.Parent.Kind = SyntaxKind.SyncLockBlock OrElse + node.Parent.Kind = SyntaxKind.SelectBlock OrElse + node.Parent.Kind = SyntaxKind.TryBlock OrElse + node.Parent.Kind = SyntaxKind.UsingBlock))) Return New BoundBadStatement(node, ImmutableArray(Of BoundNode).Empty, hasErrors:=True) @@ -272,11 +264,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic ' not handling here and then throwing ExceptionUtilities.UnexpectedValue in the else case, but ' there are just too many statement SyntaxKinds in VB (e.g. declarations, statements corresponding ' to blocks handled above, etc). - ' - ' PROTOTYPE(IOperation) - ' re-enable the assert once this issue is fixed - ' https://github.com/dotnet/roslyn/issues/21180 - ' Debug.Assert(node.ContainsDiagnostics) + Debug.Assert(IsSemanticModelBinder OrElse node.ContainsDiagnostics) Return New BoundBadStatement(node, ImmutableArray(Of BoundNode).Empty, hasErrors:=True) End Function diff --git a/src/Compilers/VisualBasic/Portable/Operations/VisualBasicConversionExpression.vb b/src/Compilers/VisualBasic/Portable/Operations/VisualBasicConversionExpression.vb index 78c1e04aa5f25f23b71a6645c5deff537d14cb1c..a779448167850938518196ee9a108656d189cea8 100644 --- a/src/Compilers/VisualBasic/Portable/Operations/VisualBasicConversionExpression.vb +++ b/src/Compilers/VisualBasic/Portable/Operations/VisualBasicConversionExpression.vb @@ -7,8 +7,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic Friend MustInherit Class BaseVisualBasicConversionExpression Inherits BaseConversionExpression - Protected Sub New(conversion As Conversion, isExplicitInCode As Boolean, isTryCast As Boolean, isChecked As Boolean, semanticModel As SemanticModel, syntax As SyntaxNode, type As ITypeSymbol, constantValue As [Optional](Of Object)) - MyBase.New(isExplicitInCode, isTryCast, isChecked, semanticModel, syntax, type, constantValue) + Protected Sub New(conversion As Conversion, isExplicitInCode As Boolean, isTryCast As Boolean, isChecked As Boolean, semanticModel As SemanticModel, syntax As SyntaxNode, type As ITypeSymbol, constantValue As [Optional](Of Object), isImplicit As Boolean) + MyBase.New(isExplicitInCode, isTryCast, isChecked, semanticModel, syntax, type, constantValue, isImplicit) ConversionInternal = conversion End Sub @@ -21,8 +21,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic Friend NotInheritable Class VisualBasicConversionExpression Inherits BaseVisualBasicConversionExpression - Public Sub New(operand As IOperation, conversion As Conversion, isExplicitInCode As Boolean, isTryCast As Boolean, isChecked As Boolean, semanticModel As SemanticModel, syntax As SyntaxNode, type As ITypeSymbol, constantValue As [Optional](Of Object)) - MyBase.New(conversion, isExplicitInCode, isTryCast, isChecked, semanticModel, syntax, type, constantValue) + Public Sub New(operand As IOperation, conversion As Conversion, isExplicitInCode As Boolean, isTryCast As Boolean, isChecked As Boolean, semanticModel As SemanticModel, syntax As SyntaxNode, type As ITypeSymbol, constantValue As [Optional](Of Object), isImplicit As Boolean) + MyBase.New(conversion, isExplicitInCode, isTryCast, isChecked, semanticModel, syntax, type, constantValue, isImplicit) Me.OperandImpl = operand End Sub @@ -35,8 +35,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic Private ReadOnly _operandLazy As Lazy(Of IOperation) - Public Sub New(operandLazy As Lazy(Of IOperation), conversion As Conversion, isExplicitInCode As Boolean, isTryCast As Boolean, isChecked As Boolean, semanticModel As SemanticModel, syntax As SyntaxNode, type As ITypeSymbol, constantValue As [Optional](Of Object)) - MyBase.New(conversion, isExplicitInCode, isTryCast, isChecked, semanticModel, syntax, type, constantValue) + Public Sub New(operandLazy As Lazy(Of IOperation), conversion As Conversion, isExplicitInCode As Boolean, isTryCast As Boolean, isChecked As Boolean, semanticModel As SemanticModel, syntax As SyntaxNode, type As ITypeSymbol, constantValue As [Optional](Of Object), isImplicit As Boolean) + MyBase.New(conversion, isExplicitInCode, isTryCast, isChecked, semanticModel, syntax, type, constantValue, isImplicit) _operandLazy = operandLazy End Sub diff --git a/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationCloner.vb b/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationCloner.vb index 9ce41edb731d9083a0362436132985da2b9665ab..780e137ed8c51dd0da28751780b03b066a0b3a5e 100644 --- a/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationCloner.vb +++ b/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationCloner.vb @@ -8,7 +8,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic Public Shared ReadOnly Property Instance As OperationCloner = New VisualBasicOperationCloner() Public Overrides Function VisitConversionExpression(operation As IConversionExpression, argument As Object) As IOperation - Return New VisualBasicConversionExpression(Visit(operation.Operand), operation.GetConversion(), operation.IsExplicitInCode, operation.IsTryCast, operation.IsChecked, DirectCast(operation, Operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue) + Return New VisualBasicConversionExpression(Visit(operation.Operand), operation.GetConversion(), operation.IsExplicitInCode, operation.IsTryCast, operation.IsChecked, DirectCast(operation, Operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit) End Function End Class End Namespace diff --git a/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationFactory.vb b/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationFactory.vb index a2c3edd068a4af83da6ebcc06b73645679190e54..e32148f91386d2921190de10ba1c37cfcf697c68 100644 --- a/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationFactory.vb +++ b/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationFactory.vb @@ -234,7 +234,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Return CreateBoundAnonymousTypePropertyAccessOperation(DirectCast(boundNode, BoundAnonymousTypePropertyAccess)) Case Else Dim constantValue = ConvertToOptional(TryCast(boundNode, BoundExpression)?.ConstantValueOpt) - Return Operation.CreateOperationNone(_semanticModel, boundNode.Syntax, constantValue, Function() GetIOperationChildren(boundNode)) + Dim isImplicit As Boolean = boundNode.WasCompilerGenerated + Return Operation.CreateOperationNone(_semanticModel, boundNode.Syntax, constantValue, Function() GetIOperationChildren(boundNode), isImplicit) End Select End Function @@ -255,6 +256,7 @@ Namespace Microsoft.CodeAnalysis.Semantics Private Function CreateBoundAssignmentOperatorOperation(boundAssignmentOperator As BoundAssignmentOperator) As IOperation Dim kind = GetAssignmentKind(boundAssignmentOperator) + Dim isImplicit As Boolean = boundAssignmentOperator.WasCompilerGenerated If kind = OperationKind.CompoundAssignmentExpression Then ' convert Right to IOperation temporarily. we do this to get right operand, operator method and etc Dim temporaryRight = DirectCast(Create(boundAssignmentOperator.Right), IBinaryOperatorExpression) @@ -272,23 +274,24 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundAssignmentOperator.Syntax Dim type As ITypeSymbol = boundAssignmentOperator.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundAssignmentOperator.ConstantValueOpt) - Return New LazyCompoundAssignmentExpression(binaryOperationKind, boundAssignmentOperator.Type.IsNullableType(), target, value, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue) + Return New LazyCompoundAssignmentExpression(binaryOperationKind, boundAssignmentOperator.Type.IsNullableType(), target, value, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue, isImplicit) Else Dim target As Lazy(Of IOperation) = New Lazy(Of IOperation)(Function() Create(boundAssignmentOperator.Left)) Dim value As Lazy(Of IOperation) = New Lazy(Of IOperation)(Function() Create(boundAssignmentOperator.Right)) Dim syntax As SyntaxNode = boundAssignmentOperator.Syntax Dim type As ITypeSymbol = boundAssignmentOperator.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundAssignmentOperator.ConstantValueOpt) - Return New LazySimpleAssignmentExpression(target, value, _semanticModel, syntax, type, constantValue) + Return New LazySimpleAssignmentExpression(target, value, _semanticModel, syntax, type, constantValue, isImplicit) End If End Function Private Function CreateBoundMeReferenceOperation(boundMeReference As BoundMeReference) As IInstanceReferenceExpression - Dim instanceReferenceKind As InstanceReferenceKind = If(boundMeReference.WasCompilerGenerated, InstanceReferenceKind.Implicit, InstanceReferenceKind.Explicit) + Dim instanceReferenceKind As InstanceReferenceKind = If(boundMeReference.WasCompilerGenerated, instanceReferenceKind.Implicit, instanceReferenceKind.Explicit) Dim syntax As SyntaxNode = boundMeReference.Syntax Dim type As ITypeSymbol = boundMeReference.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundMeReference.ConstantValueOpt) - Return New InstanceReferenceExpression(instanceReferenceKind, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundMeReference.WasCompilerGenerated + Return New InstanceReferenceExpression(instanceReferenceKind, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundMyBaseReferenceOperation(boundMyBaseReference As BoundMyBaseReference) As IInstanceReferenceExpression @@ -296,7 +299,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundMyBaseReference.Syntax Dim type As ITypeSymbol = boundMyBaseReference.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundMyBaseReference.ConstantValueOpt) - Return New InstanceReferenceExpression(instanceReferenceKind, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundMyBaseReference.WasCompilerGenerated + Return New InstanceReferenceExpression(instanceReferenceKind, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundMyClassReferenceOperation(boundMyClassReference As BoundMyClassReference) As IInstanceReferenceExpression @@ -304,7 +308,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundMyClassReference.Syntax Dim type As ITypeSymbol = boundMyClassReference.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundMyClassReference.ConstantValueOpt) - Return New InstanceReferenceExpression(instanceReferenceKind, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundMyClassReference.WasCompilerGenerated + Return New InstanceReferenceExpression(instanceReferenceKind, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundLiteralOperation(boundLiteral As BoundLiteral) As ILiteralExpression @@ -312,7 +317,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundLiteral.Syntax Dim type As ITypeSymbol = boundLiteral.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundLiteral.ConstantValueOpt) - Return New LiteralExpression(text, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundLiteral.WasCompilerGenerated + Return New LiteralExpression(text, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundAwaitOperatorOperation(boundAwaitOperator As BoundAwaitOperator) As IAwaitExpression @@ -320,7 +326,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundAwaitOperator.Syntax Dim type As ITypeSymbol = boundAwaitOperator.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundAwaitOperator.ConstantValueOpt) - Return New LazyAwaitExpression(awaitedValue, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundAwaitOperator.WasCompilerGenerated + Return New LazyAwaitExpression(awaitedValue, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundNameOfOperatorOperation(boundNameOfOperator As BoundNameOfOperator) As INameOfExpression @@ -328,7 +335,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundNameOfOperator.Syntax Dim type As ITypeSymbol = boundNameOfOperator.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundNameOfOperator.ConstantValueOpt) - Return New LazyNameOfExpression(argument, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundNameOfOperator.WasCompilerGenerated + Return New LazyNameOfExpression(argument, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundLambdaOperation(boundLambda As BoundLambda) As ILambdaExpression @@ -337,7 +345,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundLambda.Syntax Dim type As ITypeSymbol = boundLambda.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundLambda.ConstantValueOpt) - Return New LazyLambdaExpression(signature, body, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundLambda.WasCompilerGenerated + Return New LazyLambdaExpression(signature, body, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundCallOperation(boundCall As BoundCall) As IInvocationExpression @@ -360,14 +369,16 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundCall.Syntax Dim type As ITypeSymbol = boundCall.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundCall.ConstantValueOpt) - Return New LazyInvocationExpression(targetMethod, instance, isVirtual, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundCall.WasCompilerGenerated + Return New LazyInvocationExpression(targetMethod, instance, isVirtual, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundOmittedArgumentOperation(boundOmittedArgument As BoundOmittedArgument) As IOmittedArgumentExpression Dim syntax As SyntaxNode = boundOmittedArgument.Syntax Dim type As ITypeSymbol = boundOmittedArgument.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundOmittedArgument.ConstantValueOpt) - Return New OmittedArgumentExpression(_semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundOmittedArgument.WasCompilerGenerated + Return New OmittedArgumentExpression(_semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundParenthesizedOperation(boundParenthesized As BoundParenthesized) As IParenthesizedExpression @@ -375,7 +386,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundParenthesized.Syntax Dim type As ITypeSymbol = boundParenthesized.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundParenthesized.ConstantValueOpt) - Return New LazyParenthesizedExpression(operand, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundParenthesized.WasCompilerGenerated + Return New LazyParenthesizedExpression(operand, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundArrayAccessOperation(boundArrayAccess As BoundArrayAccess) As IArrayElementReferenceExpression @@ -384,7 +396,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundArrayAccess.Syntax Dim type As ITypeSymbol = boundArrayAccess.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundArrayAccess.ConstantValueOpt) - Return New LazyArrayElementReferenceExpression(arrayReference, indices, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundArrayAccess.WasCompilerGenerated + Return New LazyArrayElementReferenceExpression(arrayReference, indices, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundUnaryOperatorOperation(boundUnaryOperator As BoundUnaryOperator) As IUnaryOperatorExpression @@ -396,7 +409,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim type As ITypeSymbol = boundUnaryOperator.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundUnaryOperator.ConstantValueOpt) Dim isLifted = (boundUnaryOperator.OperatorKind And UnaryOperatorKind.Lifted) <> 0 - Return New LazyUnaryOperatorExpression(unaryOperationKind, operand, isLifted, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundUnaryOperator.WasCompilerGenerated + Return New LazyUnaryOperatorExpression(unaryOperationKind, operand, isLifted, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundUserDefinedUnaryOperatorOperation(boundUserDefinedUnaryOperator As BoundUserDefinedUnaryOperator) As IUnaryOperatorExpression @@ -413,8 +427,9 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundUserDefinedUnaryOperator.Syntax Dim type As ITypeSymbol = boundUserDefinedUnaryOperator.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundUserDefinedUnaryOperator.ConstantValueOpt) + Dim isImplicit As Boolean = boundUserDefinedUnaryOperator.WasCompilerGenerated Dim isLifted = (boundUserDefinedUnaryOperator.OperatorKind And UnaryOperatorKind.Lifted) <> 0 - Return New LazyUnaryOperatorExpression(unaryOperationKind, operand, isLifted, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue) + Return New LazyUnaryOperatorExpression(unaryOperationKind, operand, isLifted, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundBinaryOperatorOperation(boundBinaryOperator As BoundBinaryOperator) As IBinaryOperatorExpression @@ -427,7 +442,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim type As ITypeSymbol = boundBinaryOperator.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundBinaryOperator.ConstantValueOpt) Dim isLifted = (boundBinaryOperator.OperatorKind And BinaryOperatorKind.Lifted) <> 0 - Return New LazyBinaryOperatorExpression(binaryOperationKind, leftOperand, rightOperand, isLifted, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundBinaryOperator.WasCompilerGenerated + Return New LazyBinaryOperatorExpression(binaryOperationKind, leftOperand, rightOperand, isLifted, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundUserDefinedBinaryOperatorOperation(boundUserDefinedBinaryOperator As BoundUserDefinedBinaryOperator) As IBinaryOperatorExpression @@ -440,7 +456,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim type As ITypeSymbol = boundUserDefinedBinaryOperator.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundUserDefinedBinaryOperator.ConstantValueOpt) Dim isLifted = (boundUserDefinedBinaryOperator.OperatorKind And BinaryOperatorKind.Lifted) <> 0 - Return New LazyBinaryOperatorExpression(binaryOperationKind, leftOperand, rightOperand, isLifted, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundUserDefinedBinaryOperator.WasCompilerGenerated + Return New LazyBinaryOperatorExpression(binaryOperationKind, leftOperand, rightOperand, isLifted, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundBinaryConditionalExpressionOperation(boundBinaryConditionalExpression As BoundBinaryConditionalExpression) As INullCoalescingExpression @@ -449,7 +466,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundBinaryConditionalExpression.Syntax Dim type As ITypeSymbol = boundBinaryConditionalExpression.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundBinaryConditionalExpression.ConstantValueOpt) - Return New LazyNullCoalescingExpression(primaryOperand, secondaryOperand, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundBinaryConditionalExpression.WasCompilerGenerated + Return New LazyNullCoalescingExpression(primaryOperand, secondaryOperand, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundUserDefinedShortCircuitingOperatorOperation(boundUserDefinedShortCircuitingOperator As BoundUserDefinedShortCircuitingOperator) As IBinaryOperatorExpression @@ -462,7 +480,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim type As ITypeSymbol = boundUserDefinedShortCircuitingOperator.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundUserDefinedShortCircuitingOperator.ConstantValueOpt) Dim isLifted = (boundUserDefinedShortCircuitingOperator.BitwiseOperator.OperatorKind And BinaryOperatorKind.Lifted) <> 0 - Return New LazyBinaryOperatorExpression(binaryOperationKind, leftOperand, rightOperand, isLifted, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundUserDefinedShortCircuitingOperator.WasCompilerGenerated + Return New LazyBinaryOperatorExpression(binaryOperationKind, leftOperand, rightOperand, isLifted, usesOperatorMethod, operatorMethod, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundBadExpressionOperation(boundBadExpression As BoundBadExpression) As IInvalidExpression @@ -470,7 +489,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundBadExpression.Syntax Dim type As ITypeSymbol = boundBadExpression.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundBadExpression.ConstantValueOpt) - Return New LazyInvalidExpression(children, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundBadExpression.WasCompilerGenerated + Return New LazyInvalidExpression(children, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundTryCastOperation(boundTryCast As BoundTryCast) As IConversionExpression @@ -482,7 +502,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim isChecked = False Dim type As ITypeSymbol = boundTryCast.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundTryCast.ConstantValueOpt) - Return New LazyVisualBasicConversionExpression(operand, conversion, isExplicitCastInCode, isTryCast, isChecked, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundTryCast.WasCompilerGenerated + Return New LazyVisualBasicConversionExpression(operand, conversion, isExplicitCastInCode, isTryCast, isChecked, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundDirectCastOperation(boundDirectCast As BoundDirectCast) As IConversionExpression @@ -494,7 +515,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim isChecked = False Dim type As ITypeSymbol = boundDirectCast.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundDirectCast.ConstantValueOpt) - Return New LazyVisualBasicConversionExpression(operand, conversion, isExplicit, isTryCast, isChecked, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundDirectCast.WasCompilerGenerated + Return New LazyVisualBasicConversionExpression(operand, conversion, isExplicit, isTryCast, isChecked, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundConversionOperation(boundConversion As BoundConversion) As IConversionExpression @@ -506,7 +528,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim isChecked = False Dim type As ITypeSymbol = boundConversion.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundConversion.ConstantValueOpt) - Return New LazyVisualBasicConversionExpression(operand, conversion, isExplicit, isTryCast, isChecked, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundConversion.WasCompilerGenerated + Return New LazyVisualBasicConversionExpression(operand, conversion, isExplicit, isTryCast, isChecked, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundUserDefinedConversionOperation(boundUserDefinedConversion As BoundUserDefinedConversion) As IConversionExpression @@ -518,7 +541,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim isChecked = False Dim type As ITypeSymbol = boundUserDefinedConversion.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundUserDefinedConversion.ConstantValueOpt) - Return New LazyVisualBasicConversionExpression(operand, conversion, isExplicit, isTryCast, isChecked, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundUserDefinedConversion.WasCompilerGenerated + Return New LazyVisualBasicConversionExpression(operand, conversion, isExplicit, isTryCast, isChecked, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundTernaryConditionalExpressionOperation(boundTernaryConditionalExpression As BoundTernaryConditionalExpression) As IConditionalChoiceExpression @@ -528,7 +552,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundTernaryConditionalExpression.Syntax Dim type As ITypeSymbol = boundTernaryConditionalExpression.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundTernaryConditionalExpression.ConstantValueOpt) - Return New LazyConditionalChoiceExpression(condition, ifTrueValue, ifFalseValue, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundTernaryConditionalExpression.WasCompilerGenerated + Return New LazyConditionalChoiceExpression(condition, ifTrueValue, ifFalseValue, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundTypeOfOperation(boundTypeOf As BoundTypeOf) As IIsTypeExpression @@ -537,7 +562,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundTypeOf.Syntax Dim type As ITypeSymbol = boundTypeOf.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundTypeOf.ConstantValueOpt) - Return New LazyIsTypeExpression(operand, isType, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundTypeOf.WasCompilerGenerated + Return New LazyIsTypeExpression(operand, isType, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundObjectCreationExpressionOperation(boundObjectCreationExpression As BoundObjectCreationExpression) As IObjectCreationExpression @@ -558,7 +584,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundObjectCreationExpression.Syntax Dim type As ITypeSymbol = boundObjectCreationExpression.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundObjectCreationExpression.ConstantValueOpt) - Return New LazyObjectCreationExpression(constructor, memberInitializers, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundObjectCreationExpression.WasCompilerGenerated + Return New LazyObjectCreationExpression(constructor, memberInitializers, argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundObjectInitializerExpressionOperation(boundObjectInitializerExpression As BoundObjectInitializerExpression) As IObjectOrCollectionInitializerExpression @@ -566,7 +593,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundObjectInitializerExpression.Syntax Dim type As ITypeSymbol = boundObjectInitializerExpression.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundObjectInitializerExpression.ConstantValueOpt) - Return New LazyObjectOrCollectionInitializerExpression(initializers, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundObjectInitializerExpression.WasCompilerGenerated + Return New LazyObjectOrCollectionInitializerExpression(initializers, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundCollectionInitializerExpressionOperation(boundCollectionInitializerExpression As BoundCollectionInitializerExpression) As IObjectOrCollectionInitializerExpression @@ -574,7 +602,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundCollectionInitializerExpression.Syntax Dim type As ITypeSymbol = boundCollectionInitializerExpression.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundCollectionInitializerExpression.ConstantValueOpt) - Return New LazyObjectOrCollectionInitializerExpression(initializers, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundCollectionInitializerExpression.WasCompilerGenerated + Return New LazyObjectOrCollectionInitializerExpression(initializers, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundCollectionElementInitializerOperation(boundExpression As BoundExpression) As IOperation @@ -589,7 +618,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundExpression.Syntax Dim type As ITypeSymbol = boundExpression.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundExpression.ConstantValueOpt) - Return New LazyCollectionElementInitializerExpression(addMethod, arguments, isDynamic, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundExpression.WasCompilerGenerated + Return New LazyCollectionElementInitializerExpression(addMethod, arguments, isDynamic, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundNewTOperation(boundNewT As BoundNewT) As ITypeParameterObjectCreationExpression @@ -597,7 +627,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundNewT.Syntax Dim type As ITypeSymbol = boundNewT.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundNewT.ConstantValueOpt) - Return New LazyTypeParameterObjectCreationExpression(initializer, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundNewT.WasCompilerGenerated + Return New LazyTypeParameterObjectCreationExpression(initializer, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundArrayCreationOperation(boundArrayCreation As BoundArrayCreation) As IArrayCreationExpression @@ -607,7 +638,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundArrayCreation.Syntax Dim type As ITypeSymbol = boundArrayCreation.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundArrayCreation.ConstantValueOpt) - Return New LazyArrayCreationExpression(elementType, dimensionSizes, initializer, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundArrayCreation.WasCompilerGenerated + Return New LazyArrayCreationExpression(elementType, dimensionSizes, initializer, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundArrayInitializationOperation(boundArrayInitialization As BoundArrayInitialization) As IArrayInitializer @@ -615,7 +647,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundArrayInitialization.Syntax Dim type As ITypeSymbol = boundArrayInitialization.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundArrayInitialization.ConstantValueOpt) - Return New LazyArrayInitializer(elementValues, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundArrayInitialization.WasCompilerGenerated + Return New LazyArrayInitializer(elementValues, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundPropertyAccessOperation(boundPropertyAccess As BoundPropertyAccess) As IPropertyReferenceExpression @@ -638,7 +671,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundPropertyAccess.Syntax Dim type As ITypeSymbol = boundPropertyAccess.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundPropertyAccess.ConstantValueOpt) - Return New LazyPropertyReferenceExpression([property], instance, [property], argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundPropertyAccess.WasCompilerGenerated + Return New LazyPropertyReferenceExpression([property], instance, [property], argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundEventAccessOperation(boundEventAccess As BoundEventAccess) As IEventReferenceExpression @@ -655,7 +689,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundEventAccess.Syntax Dim type As ITypeSymbol = boundEventAccess.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundEventAccess.ConstantValueOpt) - Return New LazyEventReferenceExpression([event], instance, [event], _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundEventAccess.WasCompilerGenerated + Return New LazyEventReferenceExpression([event], instance, [event], _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundFieldAccessOperation(boundFieldAccess As BoundFieldAccess) As IFieldReferenceExpression @@ -673,7 +708,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundFieldAccess.Syntax Dim type As ITypeSymbol = boundFieldAccess.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundFieldAccess.ConstantValueOpt) - Return New LazyFieldReferenceExpression(field, instance, member, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundFieldAccess.WasCompilerGenerated + Return New LazyFieldReferenceExpression(field, instance, member, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundConditionalAccessOperation(boundConditionalAccess As BoundConditionalAccess) As IConditionalAccessExpression @@ -682,14 +718,16 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundConditionalAccess.Syntax Dim type As ITypeSymbol = boundConditionalAccess.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundConditionalAccess.ConstantValueOpt) - Return New LazyConditionalAccessExpression(conditionalValue, conditionalInstance, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundConditionalAccess.WasCompilerGenerated + Return New LazyConditionalAccessExpression(conditionalValue, conditionalInstance, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundConditionalAccessReceiverPlaceholderOperation(boundConditionalAccessReceiverPlaceholder As BoundConditionalAccessReceiverPlaceholder) As IConditionalAccessInstanceExpression Dim syntax As SyntaxNode = boundConditionalAccessReceiverPlaceholder.Syntax Dim type As ITypeSymbol = boundConditionalAccessReceiverPlaceholder.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundConditionalAccessReceiverPlaceholder.ConstantValueOpt) - Return New ConditionalAccessInstanceExpression(_semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundConditionalAccessReceiverPlaceholder.WasCompilerGenerated + Return New ConditionalAccessInstanceExpression(_semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundParameterOperation(boundParameter As BoundParameter) As IParameterReferenceExpression @@ -697,7 +735,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundParameter.Syntax Dim type As ITypeSymbol = boundParameter.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundParameter.ConstantValueOpt) - Return New ParameterReferenceExpression(parameter, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundParameter.WasCompilerGenerated + Return New ParameterReferenceExpression(parameter, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundLocalOperation(boundLocal As BoundLocal) As ILocalReferenceExpression @@ -705,7 +744,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundLocal.Syntax Dim type As ITypeSymbol = boundLocal.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundLocal.ConstantValueOpt) - Return New LocalReferenceExpression(local, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundLocal.WasCompilerGenerated + Return New LocalReferenceExpression(local, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundLateMemberAccessOperation(boundLateMemberAccess As BoundLateMemberAccess) As IDynamicMemberReferenceExpression @@ -728,7 +768,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundLateMemberAccess.Syntax Dim type As ITypeSymbol = boundLateMemberAccess.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundLateMemberAccess.ConstantValueOpt) - Return New LazyDynamicMemberReferenceExpression(instance, memberName, typeArguments, containingType, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundLateMemberAccess.WasCompilerGenerated + Return New LazyDynamicMemberReferenceExpression(instance, memberName, typeArguments, containingType, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundFieldInitializerOperation(boundFieldInitializer As BoundFieldInitializer) As IFieldInitializer @@ -738,7 +779,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundFieldInitializer.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyFieldInitializer(initializedFields, value, kind, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundFieldInitializer.WasCompilerGenerated + Return New LazyFieldInitializer(initializedFields, value, kind, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundPropertyInitializerOperation(boundPropertyInitializer As BoundPropertyInitializer) As IPropertyInitializer @@ -748,7 +790,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundPropertyInitializer.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyPropertyInitializer(initializedProperty, value, kind, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundPropertyInitializer.WasCompilerGenerated + Return New LazyPropertyInitializer(initializedProperty, value, kind, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundParameterEqualsValueOperation(boundParameterEqualsValue As BoundParameterEqualsValue) As IParameterInitializer @@ -758,14 +801,16 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundParameterEqualsValue.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyParameterInitializer(parameter, value, kind, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundParameterEqualsValue.WasCompilerGenerated + Return New LazyParameterInitializer(parameter, value, kind, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundRValuePlaceholderOperation(boundRValuePlaceholder As BoundRValuePlaceholder) As IPlaceholderExpression Dim syntax As SyntaxNode = boundRValuePlaceholder.Syntax Dim type As ITypeSymbol = boundRValuePlaceholder.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundRValuePlaceholder.ConstantValueOpt) - Return New PlaceholderExpression(_semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundRValuePlaceholder.WasCompilerGenerated + Return New PlaceholderExpression(_semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundIfStatementOperation(boundIfStatement As BoundIfStatement) As IIfStatement @@ -775,7 +820,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundIfStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyIfStatement(condition, ifTrueStatement, ifFalseStatement, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundIfStatement.WasCompilerGenerated + Return New LazyIfStatement(condition, ifTrueStatement, ifFalseStatement, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundSelectStatementOperation(boundSelectStatement As BoundSelectStatement) As ISwitchStatement @@ -784,7 +830,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundSelectStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazySwitchStatement(value, cases, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundSelectStatement.WasCompilerGenerated + Return New LazySwitchStatement(value, cases, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundSimpleCaseClauseOperation(boundSimpleCaseClause As BoundSimpleCaseClause) As ISingleValueCaseClause @@ -795,7 +842,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundSimpleCaseClause.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazySingleValueCaseClause(value, equality, CaseKind, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundSimpleCaseClause.WasCompilerGenerated + Return New LazySingleValueCaseClause(value, equality, CaseKind, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundRangeCaseClauseOperation(boundRangeCaseClause As BoundRangeCaseClause) As IRangeCaseClause @@ -833,7 +881,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundRangeCaseClause.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyRangeCaseClause(minimumValue, maximumValue, CaseKind, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundRangeCaseClause.WasCompilerGenerated + Return New LazyRangeCaseClause(minimumValue, maximumValue, CaseKind, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundRelationalCaseClauseOperation(boundRelationalCaseClause As BoundRelationalCaseClause) As IRelationalCaseClause @@ -844,7 +893,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundRelationalCaseClause.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyRelationalCaseClause(value, relation, CaseKind, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundRelationalCaseClause.WasCompilerGenerated + Return New LazyRelationalCaseClause(value, relation, CaseKind, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundDoLoopStatementOperation(boundDoLoopStatement As BoundDoLoopStatement) As IWhileUntilLoopStatement @@ -856,7 +906,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundDoLoopStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyWhileUntilLoopStatement(isTopTest, isWhile, condition, LoopKind, body, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundDoLoopStatement.WasCompilerGenerated + Return New LazyWhileUntilLoopStatement(isTopTest, isWhile, condition, LoopKind, body, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundForToStatementOperation(boundForToStatement As BoundForToStatement) As IForLoopStatement @@ -889,7 +940,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundForToStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyForLoopStatement(before, atLoopBottom, locals, condition, LoopKind, body, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundForToStatement.WasCompilerGenerated + Return New LazyForLoopStatement(before, atLoopBottom, locals, condition, LoopKind, body, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundForEachStatementOperation(boundForEachStatement As BoundForEachStatement) As IForEachLoopStatement @@ -900,7 +952,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundForEachStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyForEachLoopStatement(iterationVariable, collection, LoopKind, body, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundForEachStatement.WasCompilerGenerated + Return New LazyForEachLoopStatement(iterationVariable, collection, LoopKind, body, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundTryStatementOperation(boundTryStatement As BoundTryStatement) As ITryStatement @@ -910,7 +963,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundTryStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyTryStatement(body, catches, finallyHandler, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundTryStatement.WasCompilerGenerated + Return New LazyTryStatement(body, catches, finallyHandler, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundCatchBlockOperation(boundCatchBlock As BoundCatchBlock) As ICatchClause @@ -921,7 +975,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundCatchBlock.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyCatchClause(handler, caughtType, filter, exceptionLocal, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundCatchBlock.WasCompilerGenerated + Return New LazyCatchClause(handler, caughtType, filter, exceptionLocal, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundBlockOperation(boundBlock As BoundBlock) As IBlockStatement @@ -933,7 +988,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundBlock.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyBlockStatement(statements, locals, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundBlock.WasCompilerGenerated + Return New LazyBlockStatement(statements, locals, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundBadStatementOperation(boundBadStatement As BoundBadStatement) As IInvalidStatement @@ -952,7 +1008,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundBadStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyInvalidStatement(children, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundBadStatement.WasCompilerGenerated + Return New LazyInvalidStatement(children, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundReturnStatementOperation(boundReturnStatement As BoundReturnStatement) As IReturnStatement @@ -960,7 +1017,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundReturnStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyReturnStatement(OperationKind.ReturnStatement, returnedValue, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundReturnStatement.WasCompilerGenerated + Return New LazyReturnStatement(OperationKind.ReturnStatement, returnedValue, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundThrowStatementOperation(boundThrowStatement As BoundThrowStatement) As IThrowStatement @@ -968,7 +1026,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundThrowStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyThrowStatement(thrownObject, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundThrowStatement.WasCompilerGenerated + Return New LazyThrowStatement(thrownObject, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundWhileStatementOperation(boundWhileStatement As BoundWhileStatement) As IWhileUntilLoopStatement @@ -980,7 +1039,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundWhileStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyWhileUntilLoopStatement(isTopTest, isWhile, condition, LoopKind, body, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundWhileStatement.WasCompilerGenerated + Return New LazyWhileUntilLoopStatement(isTopTest, isWhile, condition, LoopKind, body, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundDimStatementOperation(boundDimStatement As BoundDimStatement) As IVariableDeclarationStatement @@ -988,7 +1048,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundDimStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyVariableDeclarationStatement(declarations, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundDimStatement.WasCompilerGenerated + Return New LazyVariableDeclarationStatement(declarations, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundYieldStatementOperation(boundYieldStatement As BoundYieldStatement) As IReturnStatement @@ -996,7 +1057,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundYieldStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyReturnStatement(OperationKind.YieldReturnStatement, returnedValue, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundYieldStatement.WasCompilerGenerated + Return New LazyReturnStatement(OperationKind.YieldReturnStatement, returnedValue, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundLabelStatementOperation(boundLabelStatement As BoundLabelStatement) As ILabeledStatement @@ -1005,7 +1067,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundLabelStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyLabeledStatement(label, statement, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundLabelStatement.WasCompilerGenerated + Return New LazyLabeledStatement(label, statement, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundGotoStatementOperation(boundGotoStatement As BoundGotoStatement) As IBranchStatement @@ -1014,7 +1077,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundGotoStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New BranchStatement(target, branchKind, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundGotoStatement.WasCompilerGenerated + Return New BranchStatement(target, branchKind, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundContinueStatementOperation(boundContinueStatement As BoundContinueStatement) As IBranchStatement @@ -1023,7 +1087,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundContinueStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New BranchStatement(target, branchKind, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundContinueStatement.WasCompilerGenerated + Return New BranchStatement(target, branchKind, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundExitStatementOperation(boundExitStatement As BoundExitStatement) As IBranchStatement @@ -1032,7 +1097,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundExitStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New BranchStatement(target, branchKind, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundExitStatement.WasCompilerGenerated + Return New BranchStatement(target, branchKind, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundSyncLockStatementOperation(boundSyncLockStatement As BoundSyncLockStatement) As ILockStatement @@ -1041,28 +1107,32 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundSyncLockStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyLockStatement(lockedObject, body, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundSyncLockStatement.WasCompilerGenerated + Return New LazyLockStatement(lockedObject, body, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundNoOpStatementOperation(boundNoOpStatement As BoundNoOpStatement) As IEmptyStatement Dim syntax As SyntaxNode = boundNoOpStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New EmptyStatement(_semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundNoOpStatement.WasCompilerGenerated + Return New EmptyStatement(_semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundStopStatementOperation(boundStopStatement As BoundStopStatement) As IStopStatement Dim syntax As SyntaxNode = boundStopStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New StopStatement(_semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundStopStatement.WasCompilerGenerated + Return New StopStatement(_semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundEndStatementOperation(boundEndStatement As BoundEndStatement) As IEndStatement Dim syntax As SyntaxNode = boundEndStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New EndStatement(_semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundEndStatement.WasCompilerGenerated + Return New EndStatement(_semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundWithStatementOperation(boundWithStatement As BoundWithStatement) As IWithStatement @@ -1071,7 +1141,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundWithStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyWithStatement(body, value, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundWithStatement.WasCompilerGenerated + Return New LazyWithStatement(body, value, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundUsingStatementOperation(boundUsingStatement As BoundUsingStatement) As IUsingStatement @@ -1084,7 +1155,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundUsingStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyUsingStatement(body, declaration, value, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundUsingStatement.WasCompilerGenerated + Return New LazyUsingStatement(body, declaration, value, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundExpressionStatementOperation(boundExpressionStatement As BoundExpressionStatement) As IExpressionStatement @@ -1092,7 +1164,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundExpressionStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyExpressionStatement(expression, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundExpressionStatement.WasCompilerGenerated + Return New LazyExpressionStatement(expression, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundRaiseEventStatementOperation(boundRaiseEventStatement As BoundRaiseEventStatement) As IExpressionStatement @@ -1100,7 +1173,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundRaiseEventStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyExpressionStatement(expression, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundRaiseEventStatement.WasCompilerGenerated + Return New LazyExpressionStatement(expression, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundAddHandlerStatementOperation(boundAddHandlerStatement As BoundAddHandlerStatement) As IExpressionStatement @@ -1108,7 +1182,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundAddHandlerStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyExpressionStatement(expression, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundAddHandlerStatement.WasCompilerGenerated + Return New LazyExpressionStatement(expression, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundRemoveHandlerStatementOperation(boundRemoveHandlerStatement As BoundRemoveHandlerStatement) As IExpressionStatement @@ -1116,7 +1191,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundRemoveHandlerStatement.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = New [Optional](Of Object)() - Return New LazyExpressionStatement(expression, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundRemoveHandlerStatement.WasCompilerGenerated + Return New LazyExpressionStatement(expression, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundTupleExpressionOperation(boundTupleExpression As BoundTupleExpression) As ITupleExpression @@ -1124,7 +1200,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundTupleExpression.Syntax Dim type As ITypeSymbol = boundTupleExpression.Type Dim constantValue As [Optional](Of Object) = Nothing - Return New LazyTupleExpression(elements, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundTupleExpression.WasCompilerGenerated + Return New LazyTupleExpression(elements, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundInterpolatedStringExpressionOperation(boundInterpolatedString As BoundInterpolatedStringExpression) As IInterpolatedStringExpression @@ -1136,7 +1213,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundInterpolatedString.Syntax Dim type As ITypeSymbol = boundInterpolatedString.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundInterpolatedString.ConstantValueOpt) - Return New LazyInterpolatedStringExpression(parts, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundInterpolatedString.WasCompilerGenerated + Return New LazyInterpolatedStringExpression(parts, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundInterpolatedStringContentOperation(boundNode As BoundNode) As IInterpolatedStringContent @@ -1154,7 +1232,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundInterpolation.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = Nothing - Return New LazyInterpolation(expression, alignment, format, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundInterpolation.WasCompilerGenerated + Return New LazyInterpolation(expression, alignment, format, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundInterpolatedStringTextOperation(boundNode As BoundNode) As IInterpolatedStringText @@ -1162,7 +1241,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundNode.Syntax Dim type As ITypeSymbol = Nothing Dim constantValue As [Optional](Of Object) = Nothing - Return New LazyInterpolatedStringText(text, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundNode.WasCompilerGenerated + Return New LazyInterpolatedStringText(text, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundAnonymousTypeCreationExpressionOperation(boundAnonymousTypeCreationExpression As BoundAnonymousTypeCreationExpression) As IAnonymousObjectCreationExpression @@ -1174,7 +1254,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundAnonymousTypeCreationExpression.Syntax Dim type As ITypeSymbol = boundAnonymousTypeCreationExpression.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundAnonymousTypeCreationExpression.ConstantValueOpt) - Return New LazyAnonymousObjectCreationExpression(initializers, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundAnonymousTypeCreationExpression.WasCompilerGenerated + Return New LazyAnonymousObjectCreationExpression(initializers, _semanticModel, syntax, type, constantValue, isImplicit) End Function Private Function CreateBoundAnonymousTypePropertyAccessOperation(boundAnonymousTypePropertyAccess As BoundAnonymousTypePropertyAccess) As IPropertyReferenceExpression @@ -1184,7 +1265,8 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim syntax As SyntaxNode = boundAnonymousTypePropertyAccess.Syntax Dim type As ITypeSymbol = boundAnonymousTypePropertyAccess.Type Dim constantValue As [Optional](Of Object) = ConvertToOptional(boundAnonymousTypePropertyAccess.ConstantValueOpt) - Return New LazyPropertyReferenceExpression([property], instance, [property], argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue) + Dim isImplicit As Boolean = boundAnonymousTypePropertyAccess.WasCompilerGenerated + Return New LazyPropertyReferenceExpression([property], instance, [property], argumentsInEvaluationOrder, _semanticModel, syntax, type, constantValue, isImplicit) End Function End Class End Namespace diff --git a/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationFactory_Methods.vb b/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationFactory_Methods.vb index 9bcea721014adf31530a86d9e63066043c192fe9..86fd39877098e3897ad065eb63e07588021c89db 100644 --- a/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationFactory_Methods.vb +++ b/src/Compilers/VisualBasic/Portable/Operations/VisualBasicOperationFactory_Methods.vb @@ -41,8 +41,8 @@ Namespace Microsoft.CodeAnalysis.Semantics If child IsNot Nothing Then Return child End If - - Return OperationFactory.CreateInvalidExpression(_semanticModel, [operator].UnderlyingExpression.Syntax, ImmutableArray(Of IOperation).Empty) + Dim isImplicit As Boolean = [operator].WasCompilerGenerated + Return OperationFactory.CreateInvalidExpression(_semanticModel, [operator].UnderlyingExpression.Syntax, ImmutableArray(Of IOperation).Empty, isImplicit) End Function Private Shared Function GetUserDefinedBinaryOperatorChildBoundNode([operator] As BoundUserDefinedBinaryOperator, index As Integer) As BoundNode @@ -72,6 +72,7 @@ Namespace Microsoft.CodeAnalysis.Semantics End Function Private Function DeriveArgument(index As Integer, argument As BoundExpression, parameters As ImmutableArray(Of VisualBasic.Symbols.ParameterSymbol)) As IArgument + Dim isImplicit As Boolean = argument.WasCompilerGenerated Select Case argument.Kind Case BoundKind.ByRefArgumentWithCopyBack Dim byRefArgument = DirectCast(argument, BoundByRefArgumentWithCopyBack) @@ -86,7 +87,8 @@ Namespace Microsoft.CodeAnalysis.Semantics _semanticModel, value.Syntax, type:=Nothing, - constantValue:=Nothing) + constantValue:=Nothing, + isImplicit:=isImplicit) Case Else Dim lastParameterIndex = parameters.Length - 1 If index = lastParameterIndex AndAlso ParameterIsParamArray(parameters(lastParameterIndex)) Then @@ -107,7 +109,8 @@ Namespace Microsoft.CodeAnalysis.Semantics semanticModel:=_semanticModel, syntax:=value.Syntax, type:=Nothing, - constantValue:=Nothing) + constantValue:=Nothing, + isImplicit:=isImplicit) Else ' TODO: figure our if this is true: ' a compiler generated argument for an Optional parameter is created iff @@ -126,7 +129,8 @@ Namespace Microsoft.CodeAnalysis.Semantics semanticModel:=_semanticModel, syntax:=value.Syntax, type:=Nothing, - constantValue:=Nothing) + constantValue:=Nothing, + isImplicit:=isImplicit) End If End Select End Function @@ -140,8 +144,8 @@ Namespace Microsoft.CodeAnalysis.Semantics If child IsNot Nothing Then Return child End If - - Return OperationFactory.CreateInvalidExpression(_semanticModel, parent.Syntax, ImmutableArray(Of IOperation).Empty) + Dim isImplicit As Boolean = parent.WasCompilerGenerated + Return OperationFactory.CreateInvalidExpression(_semanticModel, parent.Syntax, ImmutableArray(Of IOperation).Empty, isImplicit) End Function Private Shared Function GetChildOfBadExpressionBoundNode(parent As BoundNode, index As Integer) As BoundNode @@ -175,7 +179,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, _semanticModel, syntax, type, constantValue) + Dim assignment = New SimpleAssignmentExpression(target, value, _semanticModel, syntax, type, constantValue, isImplicit:=value.IsImplicit) builder.Add(assignment) Next i @@ -189,20 +193,22 @@ Namespace Microsoft.CodeAnalysis.Semantics ' so we explicitly create an IOperation node for Case-Else clause to differentiate it from Case clause. Dim clauses As ImmutableArray(Of ICaseClause) Dim caseStatement = boundCaseBlock.CaseStatement + Dim isImplicit As Boolean = boundCaseBlock.WasCompilerGenerated If caseStatement.CaseClauses.IsEmpty AndAlso caseStatement.Syntax.Kind() = SyntaxKind.CaseElseStatement Then clauses = ImmutableArray.Create(Of ICaseClause)( New DefaultCaseClause( _semanticModel, caseStatement.Syntax, type:=Nothing, - constantValue:=Nothing)) + constantValue:=Nothing, + isImplicit:=isImplicit)) Else clauses = caseStatement.CaseClauses.SelectAsArray(Function(n) DirectCast(Create(n), ICaseClause)) End If Dim body = ImmutableArray.Create(Create(boundCaseBlock.Body)) Dim syntax = boundCaseBlock.Syntax - Return DirectCast(New SwitchCase(clauses, body, _semanticModel, syntax, type:=Nothing, constantValue:=Nothing), ISwitchCase) + Return DirectCast(New SwitchCase(clauses, body, _semanticModel, syntax, type:=Nothing, constantValue:=Nothing, isImplicit:=isImplicit), ISwitchCase) End Function) End Function @@ -264,7 +270,7 @@ Namespace Microsoft.CodeAnalysis.Semantics ' ControlVariable = InitialValue If controlVariable IsNot Nothing Then - statements.Add(OperationFactory.CreateSimpleAssignmentExpressionStatement(Create(controlVariable), Create(initialValue), _semanticModel, initialValue.Syntax)) + statements.Add(OperationFactory.CreateSimpleAssignmentExpressionStatement(Create(controlVariable), Create(initialValue), _semanticModel, initialValue.Syntax, isImplicit:=controlVariable.WasCompilerGenerated)) End If ' T0 = LimitValue @@ -276,7 +282,8 @@ Namespace Microsoft.CodeAnalysis.Semantics _semanticModel, limitValue.Syntax, limitValue.Type, - constantValue:=Nothing), limitValue, _semanticModel, limitValue.Syntax)) + constantValue:=Nothing, + isImplicit:=limitValue.IsImplicit), limitValue, _semanticModel, limitValue.Syntax, limitValue.IsImplicit)) End If ' T1 = StepValue @@ -288,7 +295,8 @@ Namespace Microsoft.CodeAnalysis.Semantics _semanticModel, stepValue.Syntax, stepValue.Type, - constantValue:=Nothing), stepValue, _semanticModel, stepValue.Syntax)) + constantValue:=Nothing, + isImplicit:=stepValue.IsImplicit), stepValue, _semanticModel, stepValue.Syntax, stepValue.IsImplicit)) End If Return statements.ToImmutableAndFree() @@ -316,11 +324,12 @@ Namespace Microsoft.CodeAnalysis.Semantics _semanticModel, value.Syntax, value.Type, - constantValue:=Nothing)) + constantValue:=Nothing, + isImplicit:=value.IsImplicit)) statements.Add(OperationFactory.CreateCompoundAssignmentExpressionStatement( controlVariable, stepOperand, Expression.DeriveAdditionKind(controlType.GetNullableUnderlyingTypeOrSelf()), controlType.IsNullableType(), - Nothing, _semanticModel, stepValueExpression.Syntax)) + Nothing, _semanticModel, stepValueExpression.Syntax, value.IsImplicit)) End If End If @@ -342,7 +351,8 @@ Namespace Microsoft.CodeAnalysis.Semantics _semanticModel, limitValueOperation.Syntax, limitValueOperation.Type, - constantValue:=Nothing)) + constantValue:=Nothing, + isImplicit:=limitValueOperation.IsImplicit)) ' controlVariable can be a BoundBadExpression in case of error Dim booleanType As ITypeSymbol = controlVariable.ExpressionSymbol?.DeclaringCompilation.GetSpecialType(SpecialType.System_Boolean) @@ -364,7 +374,7 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim relationalCode As BinaryOperationKind = Helper.DeriveBinaryOperationKind( If(stepValue IsNot Nothing AndAlso stepValue.ConstantValueOpt.IsNegativeNumeric, BinaryOperatorKind.GreaterThanOrEqual, BinaryOperatorKind.LessThanOrEqual), controlVariable) Return OperationFactory.CreateBinaryOperatorExpression( - relationalCode, _semanticModel.CloneOperation(Create(controlVariable)), limitValueReference, booleanType, _semanticModel, limitValueReference.Syntax, isLifted) + relationalCode, _semanticModel.CloneOperation(Create(controlVariable)), limitValueReference, booleanType, _semanticModel, limitValueReference.Syntax, isLifted, limitValueReference.IsImplicit) Else ' If(StepValue >= 0, ControlVariable <= LimitValue, ControlVariable >= LimitValue) Dim value = Create(stepValue) @@ -373,25 +383,27 @@ Namespace Microsoft.CodeAnalysis.Semantics _semanticModel, value.Syntax, value.Type, - constantValue:=Nothing) + constantValue:=Nothing, + isImplicit:=value.IsImplicit) Dim stepRelationalCode As BinaryOperationKind = Helper.DeriveBinaryOperationKind(BinaryOperatorKind.GreaterThanOrEqual, stepValue) Dim stepConditionIsLifted = stepValue.Type.IsNullableType() Dim stepCondition As IOperation = OperationFactory.CreateBinaryOperatorExpression(stepRelationalCode, stepValueReference, - OperationFactory.CreateLiteralExpression(Semantics.Expression.SynthesizeNumeric(stepValueReference.Type, 0), stepValue.Type, _semanticModel, stepValue.Syntax), + OperationFactory.CreateLiteralExpression(Semantics.Expression.SynthesizeNumeric(stepValueReference.Type, 0), stepValue.Type, _semanticModel, stepValue.Syntax, stepValueReference.IsImplicit), booleanType, _semanticModel, stepValue.Syntax, - stepConditionIsLifted) + stepConditionIsLifted, + stepValue.WasCompilerGenerated) Dim positiveStepRelationalCode As BinaryOperationKind = Helper.DeriveBinaryOperationKind(BinaryOperatorKind.LessThanOrEqual, controlVariable) - Dim positiveStepCondition As IOperation = OperationFactory.CreateBinaryOperatorExpression(positiveStepRelationalCode, _semanticModel.CloneOperation(Create(controlVariable)), limitValueReference, booleanType, _semanticModel, limitValueReference.Syntax, isLifted) + Dim positiveStepCondition As IOperation = OperationFactory.CreateBinaryOperatorExpression(positiveStepRelationalCode, _semanticModel.CloneOperation(Create(controlVariable)), limitValueReference, booleanType, _semanticModel, limitValueReference.Syntax, isLifted, limitValueReference.IsImplicit) Dim negativeStepRelationalCode As BinaryOperationKind = Helper.DeriveBinaryOperationKind(BinaryOperatorKind.GreaterThanOrEqual, controlVariable) - Dim negativeStepCondition As IOperation = OperationFactory.CreateBinaryOperatorExpression(negativeStepRelationalCode, _semanticModel.CloneOperation(Create(controlVariable)), _semanticModel.CloneOperation(limitValueReference), booleanType, _semanticModel, limitValueReference.Syntax, isLifted) + Dim negativeStepCondition As IOperation = OperationFactory.CreateBinaryOperatorExpression(negativeStepRelationalCode, _semanticModel.CloneOperation(Create(controlVariable)), _semanticModel.CloneOperation(limitValueReference), booleanType, _semanticModel, limitValueReference.Syntax, isLifted, limitValueReference.IsImplicit) - Return OperationFactory.CreateConditionalChoiceExpression(stepCondition, positiveStepCondition, negativeStepCondition, booleanType, _semanticModel, limitValueReference.Syntax) + Return OperationFactory.CreateConditionalChoiceExpression(stepCondition, positiveStepCondition, negativeStepCondition, booleanType, _semanticModel, limitValueReference.Syntax, limitValueReference.IsImplicit) End If End If End Function @@ -422,7 +434,8 @@ Namespace Microsoft.CodeAnalysis.Semantics _semanticModel, syntax, type:=Nothing, - constantValue:=Nothing) + constantValue:=Nothing, + isImplicit:=False) ' Declaration is always explicit End Function Private Function GetAddRemoveHandlerStatementExpression(statement As BoundAddRemoveHandlerStatement) As IOperation @@ -430,7 +443,7 @@ Namespace Microsoft.CodeAnalysis.Semantics Dim eventReference = If(eventAccess Is Nothing, Nothing, CreateBoundEventAccessOperation(eventAccess)) Dim adds = statement.Kind = BoundKind.AddHandlerStatement Return New EventAssignmentExpression( - eventReference, Create(statement.Handler), adds:=adds, semanticModel:=_semanticModel, syntax:=statement.Syntax, type:=Nothing, constantValue:=Nothing) + eventReference, Create(statement.Handler), adds:=adds, semanticModel:=_semanticModel, syntax:=statement.Syntax, type:=Nothing, constantValue:=Nothing, isImplicit:=statement.WasCompilerGenerated) End Function Private Shared Function GetConversionKind(kind As VisualBasic.ConversionKind) As Semantics.ConversionKind diff --git a/src/Test/Utilities/Portable/Diagnostics/CouldHaveMoreSpecificTypeAnalyzer.cs b/src/Test/Utilities/Portable/Diagnostics/CouldHaveMoreSpecificTypeAnalyzer.cs index 3f87c846849873443ee389be641be1d2a96fce99..f7c72ff72e6fd411b55b3867278bf3264c5fc5b9 100644 --- a/src/Test/Utilities/Portable/Diagnostics/CouldHaveMoreSpecificTypeAnalyzer.cs +++ b/src/Test/Utilities/Portable/Diagnostics/CouldHaveMoreSpecificTypeAnalyzer.cs @@ -65,7 +65,8 @@ public sealed override void Initialize(AnalysisContext context) SyntaxNode syntax = increment.Syntax; ITypeSymbol type = increment.Type; Optional constantValue = new Optional(1); - var value = new LiteralExpression(text, operationContext.Compilation.GetSemanticModel(syntax.SyntaxTree), syntax, type, constantValue); + bool isImplicit = increment.IsImplicit; + var value = new LiteralExpression(text, operationContext.Compilation.GetSemanticModel(syntax.SyntaxTree), syntax, type, constantValue, isImplicit); AssignTo(increment.Target, localsSourceTypes, fieldsSourceTypes, value); } diff --git a/src/Test/Utilities/Portable/Diagnostics/OperationTestAnalyzer.cs b/src/Test/Utilities/Portable/Diagnostics/OperationTestAnalyzer.cs index 2c723ce28e4b4fb01098d5c4e4e4c6f21d1a6bf2..ef365556bfbe2f4c83e89967b1f83b38e9fa45f0 100644 --- a/src/Test/Utilities/Portable/Diagnostics/OperationTestAnalyzer.cs +++ b/src/Test/Utilities/Portable/Diagnostics/OperationTestAnalyzer.cs @@ -286,8 +286,7 @@ private static ILiteralExpression CreateIncrementOneLiteralExpression(SemanticMo SyntaxNode syntax = increment.Syntax; ITypeSymbol type = increment.Type; Optional constantValue = new Optional(1); - - return new LiteralExpression(text, semanticModel, syntax, type, constantValue); + return new LiteralExpression(text, semanticModel, syntax, type, constantValue, increment.IsImplicit); } private static int Abs(int value)