Rebase target-typed-new branch on top of master

docs/contributing/Compiler Test Plan.md

@@ -209,6 +209,7 @@ a[e]
 x++ 
 x-- 
 new X() 
+new() 
 typeof(T) 
 default(T)
 default 

src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs

@@ -125,6 +125,11 @@ protected BoundExpression CreateConversion(
  }
  }
 
+ if (conversion.IsObjectCreation)
+ {
+ return ConvertObjectCreationExpression((BoundUnconvertedObjectCreationExpression)source, isCast, destination, diagnostics);
+ }
+
  if (conversion.IsUserDefined)
  {
  // User-defined conversions are likely to be represented as multiple
@@ -152,6 +157,64 @@ protected BoundExpression CreateConversion(
  { WasCompilerGenerated = wasCompilerGenerated };
  }
 
+ private BoundExpression ConvertObjectCreationExpression(BoundUnconvertedObjectCreationExpression node, bool isCast, TypeSymbol destination, DiagnosticBag diagnostics)
+ {
+ var arguments = AnalyzedArguments.GetInstance(node.Arguments, node.ArgumentRefKindsOpt, node.ArgumentNamesOpt);
+ BoundExpression expr = BindObjectCreationExpression(node, destination.StrippedType(), arguments, diagnostics);
+ if (destination.IsNullableType())
+ {
+ // We manually create an ImplicitNullable conversion
+ // if the destination is nullable, in which case we
+ // target the underlying type e.g. `S? x = new();`
+ // is actually identical to `S? x = new S();`.
+ var conversion = new Conversion(ConversionKind.ImplicitNullable, Conversion.IdentityUnderlying);
+ expr = new BoundConversion(
+ node.Syntax,
+ operand: expr,
+ conversion: conversion,
+ @checked: false,
+ explicitCastInCode: isCast,
+ conversionGroupOpt: new ConversionGroup(conversion),
+ constantValueOpt: expr.ConstantValue,
+ type: destination);
+ }
+ arguments.Free();
+ return expr;
+ }
+
+ private BoundExpression BindObjectCreationExpression(BoundUnconvertedObjectCreationExpression node, TypeSymbol type, AnalyzedArguments arguments, DiagnosticBag diagnostics)
+ {
+ var syntax = node.Syntax;
+ switch (type.TypeKind)
+ {
+ case TypeKind.Struct:
+ case TypeKind.Class when !type.IsAnonymousType: // We don't want to enable object creation with unspeakable types
+ return BindClassCreationExpression(syntax, type.Name, typeNode: syntax, (NamedTypeSymbol)type, arguments, diagnostics, node.InitializerOpt);
+ case TypeKind.TypeParameter:
+ return BindTypeParameterCreationExpression(syntax, (TypeParameterSymbol)type, arguments, node.InitializerOpt, typeSyntax: syntax, diagnostics);
+ case TypeKind.Delegate:
+ return BindDelegateCreationExpression(syntax, (NamedTypeSymbol)type, arguments, node.InitializerOpt, diagnostics);
+ case TypeKind.Array:
+ case TypeKind.Enum:
+ case TypeKind.Class:
+ Error(diagnostics, ErrorCode.ERR_TypelessNewIllegalTargetType, syntax, type);
+ goto case TypeKind.Error;
+ case TypeKind.Interface:
+ Error(diagnostics, ErrorCode.ERR_NoNewAbstract, syntax, type);
+ goto case TypeKind.Error;
+ case TypeKind.Pointer:
+ Error(diagnostics, ErrorCode.ERR_UnsafeTypeInObjectCreation, syntax, type);
+ goto case TypeKind.Error;
+ case TypeKind.Dynamic:
+ Error(diagnostics, ErrorCode.ERR_NoConstructors, syntax, type);
+ goto case TypeKind.Error;
+ case TypeKind.Error:
+ return MakeBadExpressionForObjectCreation(syntax, type, arguments, node.InitializerOpt, typeSyntax: syntax, diagnostics);
+ case var v:
+ throw ExceptionUtilities.UnexpectedValue(v);
+ }
+ }
+
 #nullable enable
  /// <summary>
  /// Rewrite the expressions in the switch expression arms to add a conversion to the destination type.

src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs

@@ -1548,6 +1548,7 @@ private BoundExpression BindNameofOperatorInternal(InvocationExpressionSyntax no
  }
  }
 
+ boundArgument = BindToNaturalType(boundArgument, diagnostics, reportNoTargetType: false);
  return new BoundNameOfOperator(node, boundArgument, ConstantValue.Create(name), Compilation.GetSpecialType(SpecialType.System_String));
  }
 

src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs

@@ -587,8 +587,8 @@ private BoundExpression BindSimpleBinaryOperator(BinaryExpressionSyntax node, Di
  {
  // If we found an operator, we'll have given the `default` literal a type.
  // Otherwise, we'll have reported the problem in ReportBinaryOperatorError.
- resultLeft = BindToNaturalType(resultLeft, diagnostics, reportDefaultMissingType: false);
- resultRight = BindToNaturalType(resultRight, diagnostics, reportDefaultMissingType: false);
+ resultLeft = BindToNaturalType(resultLeft, diagnostics, reportNoTargetType: false);
+ resultRight = BindToNaturalType(resultRight, diagnostics, reportNoTargetType: false);
  }
 
  hasErrors = hasErrors || resultConstant != null && resultConstant.IsBad;
@@ -653,8 +653,8 @@ private bool BindSimpleBinaryOperatorParts(BinaryExpressionSyntax node, Diagnost
  {
  resultSignature = signature;
  HashSet<DiagnosticInfo> useSiteDiagnostics = null;
- bool leftDefault = left.IsLiteralDefault();
- bool rightDefault = right.IsLiteralDefault();
+ bool leftDefault = left.IsLiteralDefaultOrTypelessNew();
+ bool rightDefault = right.IsLiteralDefaultOrTypelessNew();
  foundOperator = !isObjectEquality || BuiltInOperators.IsValidObjectEquality(Conversions, leftType, leftNull, leftDefault, rightType, rightNull, rightDefault, ref useSiteDiagnostics);
  diagnostics.Add(node, useSiteDiagnostics);
  }
@@ -699,18 +699,20 @@ private static void ReportBinaryOperatorError(ExpressionSyntax node, DiagnosticB
  {
  bool leftDefault = left.IsLiteralDefault();
  bool rightDefault = right.IsLiteralDefault();
- if ((operatorToken.Kind() == SyntaxKind.EqualsEqualsToken || operatorToken.Kind() == SyntaxKind.ExclamationEqualsToken))
+ if (operatorToken.Kind() != SyntaxKind.EqualsEqualsToken && operatorToken.Kind() != SyntaxKind.ExclamationEqualsToken)
  {
- if (leftDefault && rightDefault)
+ if (leftDefault || rightDefault)
  {
- Error(diagnostics, ErrorCode.ERR_AmbigBinaryOpsOnDefault, node, operatorToken.Text);
+ // other than == and !=, binary operators are disallowed on `default` literal
+ Error(diagnostics, ErrorCode.ERR_BadOpOnNullOrDefaultOrNew, node, operatorToken.Text, "default");
  return;
  }
  }
- else if (leftDefault || rightDefault)
+
+ if ((leftDefault || left.IsTypelessNew()) &&
+ (rightDefault || right.IsTypelessNew()))
  {
- // other than == and !=, binary operators are disallowed on `default` literal
- Error(diagnostics, ErrorCode.ERR_BadOpOnNullOrDefault, node, operatorToken.Text, "default");
+ Error(diagnostics, ErrorCode.ERR_AmbigBinaryOpsOnDefaultOrNew, node, operatorToken.Text, left.Display, right.Display);
  return;
  }
 
@@ -1113,7 +1115,7 @@ private TypeSymbol GetBinaryOperatorErrorType(BinaryOperatorKind kind, Diagnosti
 
  private BinaryOperatorAnalysisResult BinaryOperatorOverloadResolution(BinaryOperatorKind kind, BoundExpression left, BoundExpression right, CSharpSyntaxNode node, DiagnosticBag diagnostics, out LookupResultKind resultKind, out ImmutableArray<MethodSymbol> originalUserDefinedOperators)
  {
- if (!IsDefaultLiteralAllowedInBinaryOperator(kind, left, right))
+ if (!IsTypelessExpressionAllowedInBinaryOperator(kind, left, right))
  {
  resultKind = LookupResultKind.OverloadResolutionFailure;
  originalUserDefinedOperators = default(ImmutableArray<MethodSymbol>);
@@ -1182,8 +1184,21 @@ private void ReportObsoleteAndFeatureAvailabilityDiagnostics(MethodSymbol operat
  }
  }
 
- private bool IsDefaultLiteralAllowedInBinaryOperator(BinaryOperatorKind kind, BoundExpression left, BoundExpression right)
+ private bool IsTypelessExpressionAllowedInBinaryOperator(BinaryOperatorKind kind, BoundExpression left, BoundExpression right)
  {
+ // The default literal is only allowed with equality operators and both operands cannot be typeless at the same time.
+ // Note: we only need to restrict expressions that can be converted to *any* type, in which case the resolution could always succeed.
+
+ if (left.IsTypelessNew())
+ {
+ return !right.IsLiteralDefaultOrTypelessNew();
+ }
+
+ if (right.IsTypelessNew())
+ {
+ return !left.IsLiteralDefault();
+ }
+
  bool isEquality = kind == BinaryOperatorKind.Equal || kind == BinaryOperatorKind.NotEqual;
  if (isEquality)
  {
@@ -2313,7 +2328,7 @@ private BoundExpression BindUnaryOperatorCore(CSharpSyntaxNode node, string oper
  {
  // Dev10 does not allow unary prefix operators to be applied to the null literal
  // (or other typeless expressions).
- Error(diagnostics, ErrorCode.ERR_BadOpOnNullOrDefault, node, operatorText, operand.Display);
+ Error(diagnostics, ErrorCode.ERR_BadOpOnNullOrDefaultOrNew, node, operatorText, operand.Display);
  }
 
  // If the operand is bad, avoid generating cascading errors.
@@ -3420,7 +3435,7 @@ private BoundExpression BindNullCoalescingOperator(BinaryExpressionSyntax node,
  // The specification does not permit the left hand side to be a default literal
  if (leftOperand.IsLiteralDefault())
  {
- Error(diagnostics, ErrorCode.ERR_BadOpOnNullOrDefault, node, node.OperatorToken.Text, "default");
+ Error(diagnostics, ErrorCode.ERR_BadOpOnNullOrDefaultOrNew, node, node.OperatorToken.Text, "default");
 
  return new BoundNullCoalescingOperator(node, leftOperand, rightOperand,
  Conversion.NoConversion, BoundNullCoalescingOperatorResultKind.NoCommonType, CreateErrorType(), hasErrors: true);
@@ -3862,6 +3877,8 @@ private BoundExpression BindConditionalOperator(ConditionalExpressionSyntax node
  hasErrors = constantValue != null && constantValue.IsBad;
  }
 
+ trueExpr = BindToNaturalType(trueExpr, diagnostics, reportNoTargetType: false);
+ falseExpr = BindToNaturalType(falseExpr, diagnostics, reportNoTargetType: false);
  return new BoundConditionalOperator(node, isRef, condition, trueExpr, falseExpr, constantValue, type, hasErrors);
  }
 

src/Compilers/CSharp/Portable/Binder/Binder_Query.cs

@@ -735,6 +735,10 @@ protected BoundCall MakeQueryInvocation(CSharpSyntaxNode node, BoundExpression r
  {
  diagnostics.Add(ErrorCode.ERR_DefaultLiteralNotValid, node.Location);
  }
+ else if (ultimateReceiver.IsTypelessNew())
+ {
+ diagnostics.Add(ErrorCode.ERR_TypelessNewNotValid, node.Location);
+ }
  else if (ultimateReceiver.Kind == BoundKind.NamespaceExpression)
  {
  diagnostics.Add(ErrorCode.ERR_BadSKunknown, ultimateReceiver.Syntax.Location, ultimateReceiver.Syntax, MessageID.IDS_SK_NAMESPACE.Localize());

src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs

@@ -372,6 +372,13 @@ internal BoundStatement BindPossibleEmbeddedStatement(StatementSyntax node, Diag
  private BoundExpression BindThrownExpression(ExpressionSyntax exprSyntax, DiagnosticBag diagnostics, ref bool hasErrors)
  {
  var boundExpr = BindValue(exprSyntax, diagnostics, BindValueKind.RValue);
+ if (boundExpr.IsTypelessNew())
+ {
+ // NOTE This only disallows direct usage. One can simply bypass this by wrapping new() in a switch expression
+ diagnostics.Add(ErrorCode.ERR_TypelessNewNotValid, exprSyntax.Location);
+ hasErrors = true;
+ }
+
  if (Compilation.LanguageVersion < MessageID.IDS_FeatureSwitchExpression.RequiredVersion())
  {
  // This is the pre-C# 8 algorithm for binding a thrown expression.

src/Compilers/CSharp/Portable/Binder/Binder_TupleOperators.cs

@@ -44,7 +44,7 @@ private BoundExpression ApplyConvertedTypes(BoundExpression expr, TupleBinaryOpe
  var multiple = (TupleBinaryOperatorInfo.Multiple)@operator;
  if (multiple.Operators.Length == 0)
  {
- return BindToNaturalType(expr, diagnostics, reportDefaultMissingType: false);
+ return BindToNaturalType(expr, diagnostics, reportNoTargetType: false);
  }
 
  ImmutableArray<BoundExpression> arguments = tuple.Arguments;
@@ -62,7 +62,7 @@ private BoundExpression ApplyConvertedTypes(BoundExpression expr, TupleBinaryOpe
  }
 
  // This element isn't getting a converted type
- return BindToNaturalType(expr, diagnostics, reportDefaultMissingType: false);
+ return BindToNaturalType(expr, diagnostics, reportNoTargetType: false);
  }
 
  // We were able to determine a converted type (for this tuple literal or element), we can just convert to it
@@ -191,11 +191,11 @@ private TupleBinaryOperatorInfo BindTupleDynamicBinaryOperatorSingleInfo(BinaryE
  private TupleBinaryOperatorInfo.Multiple BindTupleBinaryOperatorNestedInfo(BinaryExpressionSyntax node, BinaryOperatorKind kind,
  BoundExpression left, BoundExpression right, DiagnosticBag diagnostics)
  {
- left = GiveTupleTypeToDefaultLiteralIfNeeded(left, right.Type);
- right = GiveTupleTypeToDefaultLiteralIfNeeded(right, left.Type);
+ left = GiveTupleTypeToTypelessExpressionIfNeeded(left, right.Type, diagnostics);
+ right = GiveTupleTypeToTypelessExpressionIfNeeded(right, left.Type, diagnostics);
 
- if ((left.Type is null && left.IsLiteralDefault()) ||
- (right.Type is null && right.IsLiteralDefault()))
+ if ((left.Type is null && left.IsLiteralDefaultOrTypelessNew()) ||
+ (right.Type is null && right.IsLiteralDefaultOrTypelessNew()))
  {
  Error(diagnostics, ErrorCode.ERR_AmbigBinaryOps, node, node.OperatorToken.Text, left.Display, right.Display);
  return TupleBinaryOperatorInfo.Multiple.ErrorInstance;
@@ -311,27 +311,36 @@ private static void ReportNamesMismatchesIfAny(BoundExpression left, BoundExpres
  }
  }
 
- internal static BoundExpression GiveTupleTypeToDefaultLiteralIfNeeded(BoundExpression expr, TypeSymbol targetType)
+ internal BoundExpression GiveTupleTypeToTypelessExpressionIfNeeded(BoundExpression expr, TypeSymbol targetType, DiagnosticBag diagnostics)
  {
- if (!expr.IsLiteralDefault() || targetType is null)
+ if (targetType is object)
  {
- return expr;
+ if (expr.IsLiteralDefault())
+ {
+ Debug.Assert(targetType.StrippedType().IsTupleType);
+ return new BoundDefaultExpression(expr.Syntax, targetType);
+ }
+
+ if (expr is BoundUnconvertedObjectCreationExpression objectCreation)
+ {
+ return ConvertObjectCreationExpression(objectCreation, isCast: false, targetType, diagnostics);
+ }
  }
 
- Debug.Assert(targetType.StrippedType().IsTupleType);
- return new BoundDefaultExpression(expr.Syntax, targetType);
+ return expr;
  }
 
  private static bool IsTupleBinaryOperation(BoundExpression left, BoundExpression right)
  {
- bool leftDefault = left.IsLiteralDefault();
- bool rightDefault = right.IsLiteralDefault();
- if (leftDefault && rightDefault)
+ bool leftDefaultOrNew = left.IsLiteralDefaultOrTypelessNew();
+ bool rightDefaultOrNew = right.IsLiteralDefaultOrTypelessNew();
+ if (leftDefaultOrNew && rightDefaultOrNew)
  {
  return false;
  }
 
- return (GetTupleCardinality(left) > 1 || leftDefault) && (GetTupleCardinality(right) > 1 || rightDefault);
+ return (GetTupleCardinality(left) > 1 || leftDefaultOrNew) &&
+ (GetTupleCardinality(right) > 1 || rightDefaultOrNew);
  }
 
  private static int GetTupleCardinality(BoundExpression expr)

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs

@@ -221,6 +221,7 @@ internal static Conversion GetTrivialConversion(ConversionKind kind)
  internal static Conversion ImplicitReference => new Conversion(ConversionKind.ImplicitReference);
  internal static Conversion ImplicitEnumeration => new Conversion(ConversionKind.ImplicitEnumeration);
  internal static Conversion ImplicitThrow => new Conversion(ConversionKind.ImplicitThrow);
+ internal static Conversion ObjectCreation => new Conversion(ConversionKind.ObjectCreation);
  internal static Conversion AnonymousFunction => new Conversion(ConversionKind.AnonymousFunction);
  internal static Conversion Boxing => new Conversion(ConversionKind.Boxing);
  internal static Conversion NullLiteral => new Conversion(ConversionKind.NullLiteral);
@@ -521,6 +522,17 @@ public bool IsThrow
  }
  }
 
+ /// <summary>
+ /// Returns true if the conversion is an implicit object creation expression conversion.
+ /// </summary>
+ internal bool IsObjectCreation
+ {
+ get
+ {
+ return Kind == ConversionKind.ObjectCreation;
+ }
+ }
+
  /// <summary>
  /// Returns true if the conversion is an implicit switch expression conversion.
  /// </summary>

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKind.cs

@@ -54,5 +54,6 @@ internal enum ConversionKind : byte
  PinnedObjectToPointer,
 
  DefaultLiteral, // a conversion from a `default` literal to any type
+ ObjectCreation, // a conversion from a `new()` expression to any type
  }
 }

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKindExtensions.cs

@@ -48,6 +48,7 @@ public static bool IsImplicitConversion(this ConversionKind conversionKind)
  case Deconstruction:
  case StackAllocToPointerType:
  case StackAllocToSpanType:
+ case ObjectCreation:
  return true;
 
  case ExplicitNumeric:

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs

@@ -926,6 +926,9 @@ private Conversion ClassifyImplicitBuiltInConversionFromExpression(BoundExpressi
 
  case BoundKind.ThrowExpression:
  return Conversion.ImplicitThrow;
+
+ case BoundKind.UnconvertedObjectCreationExpression:
+ return Conversion.ObjectCreation;
  }
 
  return Conversion.NoConversion;