Two bug fixes - disallow "new (int, int)()" and induce a failure if ValueTuple is not a struct.

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

@@ -3405,20 +3405,17 @@ private BoundExpression BindClassCreationExpression(ObjectCreationExpressionSynt
  // new C(__arglist()) is legal
  BindArgumentsAndNames(node.ArgumentList, diagnostics, analyzedArguments, allowArglist: true);
 
- // No point in performing overload resolution if the type is static. Just return a bad expression containing
- // the arguments.
+ // No point in performing overload resolution if the type is static or a tuple literal. 
+ // Just return a bad expression containing the arguments.
  if (type.IsStatic)
  {
  diagnostics.Add(ErrorCode.ERR_InstantiatingStaticClass, node.Location, type);
-
- var children = ArrayBuilder<BoundNode>.GetInstance();
- children.AddRange(BuildArgumentsForErrorRecovery(analyzedArguments));
- if (boundInitializerOpt != null)
- {
- children.Add(boundInitializerOpt);
- }
-
- return new BoundBadExpression(node, LookupResultKind.NotCreatable, ImmutableArray.Create<Symbol>(type), children.ToImmutableAndFree(), type);
+ return MakeBadExpressionForObjectCreation(node, type, boundInitializerOpt, analyzedArguments);
+ }
+ else if (node.Type.Kind() == SyntaxKind.TupleType)
+ {
+ Debug.Assert(node.HasErrors, "new <tuple type> should be a syntax error");
+ return MakeBadExpressionForObjectCreation(node, type, boundInitializerOpt, analyzedArguments);
  }
 
  return BindClassCreationExpression(node, typeName, node.Type, type, analyzedArguments, diagnostics, boundInitializerOpt);
@@ -3429,6 +3426,18 @@ private BoundExpression BindClassCreationExpression(ObjectCreationExpressionSynt
  }
  }
 
+ private BoundExpression MakeBadExpressionForObjectCreation(ObjectCreationExpressionSyntax node, NamedTypeSymbol type, BoundExpression boundInitializerOpt, AnalyzedArguments analyzedArguments)
+ {
+ var children = ArrayBuilder<BoundNode>.GetInstance();
+ children.AddRange(BuildArgumentsForErrorRecovery(analyzedArguments));
+ if (boundInitializerOpt != null)
+ {
+ children.Add(boundInitializerOpt);
+ }
+
+ return new BoundBadExpression(node, LookupResultKind.NotCreatable, ImmutableArray.Create<Symbol>(type), children.ToImmutableAndFree(), type);
+ }
+
  private BoundExpression BindInitializerExpressionOrValue(
  ExpressionSyntax syntax,
  TypeSymbol type,

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -4930,6 +4930,12 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
  <data name="WRN_TupleLiteralNameMismatch_Title" xml:space="preserve">
  <value>The tuple element name is ignored because a different name is specified by the assignment target.</value>
  </data>
+ <data name="ERR_PredefinedValueTupleTypeMustBeStruct" xml:space="preserve">
+ <value>Predefined type '{0}' must be a struct.</value>
+ </data>
+ <data name="ERR_NewWithTupleTypeSyntax" xml:space="preserve">
+ <value>'new' cannot be used with tuple type. Use a tuple literal expression instead.</value>
+ </data>
  <data name="ERR_DeconstructionVarFormDisallowsSpecificType" xml:space="preserve">
  <value>Deconstruction 'var (...)' form disallows a specific type for 'var'.</value>
  </data>

src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs

@@ -21,7 +21,7 @@ internal abstract class PEModuleBuilder : PEModuleBuilder<CSharpCompilation, Sou
  // TODO: Need to estimate amount of elements for this map and pass that value to the constructor. 
  protected readonly ConcurrentDictionary<Symbol, Cci.IModuleReference> AssemblyOrModuleSymbolToModuleRefMap = new ConcurrentDictionary<Symbol, Cci.IModuleReference>();
  private readonly ConcurrentDictionary<Symbol, object> _genericInstanceMap = new ConcurrentDictionary<Symbol, object>();
- private readonly ConcurrentSet<ErrorTypeSymbol> _reportedErrorTypesMap = new ConcurrentSet<ErrorTypeSymbol>();
+ private readonly ConcurrentSet<TypeSymbol> _reportedErrorTypesMap = new ConcurrentSet<TypeSymbol>();
 
  private readonly NoPia.EmbeddedTypesManager _embeddedTypesManagerOpt;
  public override NoPia.EmbeddedTypesManager EmbeddedTypesManagerOpt
@@ -790,6 +790,7 @@ internal Cci.INamedTypeReference Translate(
  {
  Debug.Assert(!needDeclaration);
  namedTypeSymbol = namedTypeSymbol.TupleUnderlyingType;
+ CheckTupleUnderlying(namedTypeSymbol, syntaxNodeOpt, diagnostics);
  }
 
  // Substitute error types with a special singleton object.
@@ -890,6 +891,23 @@ internal Cci.INamedTypeReference Translate(
  return namedTypeSymbol;
  }
 
+ private void CheckTupleUnderlying(NamedTypeSymbol namedTypeSymbol, SyntaxNode syntaxNodeOpt, DiagnosticBag diagnostics)
+ {
+ // check that underlying type of a ValueTuple is indeed a value type (or error)
+ // this should never happen, in theory,
+ // but if it does happen we should make it a failure.
+ // NOTE: declaredBase could be null for interfaces
+ var declaredBase = namedTypeSymbol.BaseTypeNoUseSiteDiagnostics;
+ if (declaredBase?.SpecialType != SpecialType.System_ValueType && declaredBase?.IsErrorType() != true)
+ {
+ // Try to decrease noise by not complaining about the same type over and over again.
+ if (_reportedErrorTypesMap.Add(namedTypeSymbol))
+ {
+ diagnostics.Add(new CSDiagnostic(new CSDiagnosticInfo(ErrorCode.ERR_PredefinedValueTupleTypeMustBeStruct, namedTypeSymbol.MetadataName), syntaxNodeOpt == null ? NoLocation.Singleton : syntaxNodeOpt.Location));
+ }
+ }
+ }
+
  public static bool IsGenericType(NamedTypeSymbol toCheck)
  {
  while ((object)toCheck != null)

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -1428,8 +1428,10 @@ internal enum ErrorCode
 
  ERR_PredefinedValueTupleTypeNotFound = 8179,
  ERR_SemiOrLBraceOrArrowExpected = 8180,
+ ERR_NewWithTupleTypeSyntax = 8181,
+ ERR_PredefinedValueTupleTypeMustBeStruct = 8182,
 
- // Available = 8181-8195
+ // Available = 8183-8195
 
  #region diagnostics for out var
  ERR_ImplicitlyTypedOutVariableUsedInTheSameArgumentList = 8196,

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

@@ -10676,7 +10676,13 @@ private ExpressionSyntax ParseArrayOrObjectCreationExpression()
  SyntaxFactory.MissingToken(SyntaxKind.CloseParenToken));
  }
 
- return _syntaxFactory.ObjectCreationExpression(@new, type, argumentList, initializer);
+ var objectCreation = _syntaxFactory.ObjectCreationExpression(@new, type, argumentList, initializer);
+ if (type.Kind == SyntaxKind.TupleType)
+ {
+ objectCreation = this.AddError(objectCreation, type, ErrorCode.ERR_NewWithTupleTypeSyntax);
+ }
+
+ return objectCreation;
  }
  }
 

src/Compilers/CSharp/Portable/Symbols/Tuples/TupleTypeSymbol.cs

@@ -663,22 +663,6 @@ internal override ImmutableArray<NamedTypeSymbol> InterfacesNoUseSiteDiagnostics
  return _underlyingType.InterfacesNoUseSiteDiagnostics(basesBeingResolved);
  }
 
- public override bool IsReferenceType
- {
- get
- {
- return _underlyingType.IsErrorType() ? false : _underlyingType.IsReferenceType;
- }
- }
-
- public override bool IsValueType
- {
- get
- {
- return _underlyingType.IsErrorType() || _underlyingType.IsValueType;
- }
- }
-
  internal sealed override bool IsManagedType
  {
  get
@@ -1097,10 +1081,9 @@ public override TypeKind TypeKind
  {
  get
  {
- // only classes and structs can have instance fields as tuple requires.
- // we need to have some support for classes, but most common case will be struct
- // in broken scenarios (ErrorType, Enum, Delegate, whatever..) we will just default to struct.
- return _underlyingType.TypeKind == TypeKind.Class ? TypeKind.Class : TypeKind.Struct;
+ // From the language perspective tuple is a value type 
+ // composed of its underlying elements
+ return TypeKind.Struct;
  }
  }