@@ -12405,17 +12405,32 @@ func (c *Checker) checkNullishCoalesceOperands(left *ast.Node, right *ast.Node)
1240512405 if ast.IsBinaryExpression(right) && ast.IsLogicalBinaryOperator(right.AsBinaryExpression().OperatorToken.Kind) {
1240612406 c.grammarErrorOnNode(right, diagnostics.X_0_and_1_operations_cannot_be_mixed_without_parentheses, scanner.TokenToString(right.AsBinaryExpression().OperatorToken.Kind), scanner.TokenToString(ast.KindQuestionQuestionToken))
1240712407 }
12408+ c.checkNullishCoalesceOperandLeft(left)
12409+ c.checkNullishCoalesceOperandRight(right)
12410+ }
12411+
12412+ func (c *Checker) checkNullishCoalesceOperandLeft(left *ast.Node) {
1240812413 leftTarget := ast.SkipOuterExpressions(left, ast.OEKAll)
1240912414 nullishSemantics := c.getSyntacticNullishnessSemantics(leftTarget)
1241012415 if nullishSemantics != PredicateSemanticsSometimes {
12411- if left.Parent.Parent.Kind == ast.KindBinaryExpression {
12412- c.error(leftTarget, diagnostics.This_binary_expression_is_never_nullish_Are_you_missing_parentheses )
12416+ if nullishSemantics == PredicateSemanticsAlways {
12417+ c.error(leftTarget, diagnostics.This_expression_is_always_nullish )
1241312418 } else {
12414- if nullishSemantics == PredicateSemanticsAlways {
12415- c.error(leftTarget, diagnostics.This_expression_is_always_nullish)
12416- } else {
12417- c.error(leftTarget, diagnostics.Right_operand_of_is_unreachable_because_the_left_operand_is_never_nullish)
12418- }
12419+ c.error(leftTarget, diagnostics.Right_operand_of_is_unreachable_because_the_left_operand_is_never_nullish)
12420+ }
12421+ }
12422+ }
12423+
12424+ func (c *Checker) checkNullishCoalesceOperandRight(right *ast.Node) {
12425+ binaryExpression := right.Parent
12426+ if binaryExpression.Parent != nil && ast.IsBinaryExpression(binaryExpression.Parent) && binaryExpression.Parent.AsBinaryExpression().OperatorToken.Kind == ast.KindQuestionQuestionToken {
12427+ rightTarget := ast.SkipOuterExpressions(right, ast.OEKAll)
12428+ nullishSemantics := c.getSyntacticNullishnessSemantics(rightTarget)
12429+ switch nullishSemantics {
12430+ case PredicateSemanticsAlways:
12431+ c.error(rightTarget, diagnostics.This_expression_is_always_nullish)
12432+ case PredicateSemanticsNever:
12433+ c.error(rightTarget, diagnostics.This_expression_is_never_nullish)
1241912434 }
1242012435 }
1242112436}
@@ -15393,9 +15408,7 @@ func (c *Checker) addDeclarationToLateBoundSymbol(symbol *ast.Symbol, member *as
1539315408 symbol.Declarations = append(symbol.Declarations, member)
1539415409 }
1539515410 if symbolFlags&ast.SymbolFlagsValue != 0 {
15396- if symbol.ValueDeclaration == nil || symbol.ValueDeclaration.Kind != member.Kind {
15397- symbol.ValueDeclaration = member
15398- }
15411+ binder.SetValueDeclaration(symbol, member)
1539915412 }
1540015413}
1540115414
@@ -15700,14 +15713,14 @@ func (c *Checker) getWriteTypeOfSymbolWithDeferredType(symbol *ast.Symbol) *Type
1570015713// properties deriving from set accessors will either pre-compute or defer the union or
1570115714// intersection of the writeTypes of their constituents.
1570215715func (c *Checker) getWriteTypeOfSymbol(symbol *ast.Symbol) *Type {
15703- if symbol.Flags&ast.SymbolFlagsProperty != 0 {
15704- if symbol.CheckFlags&ast.CheckFlagsSyntheticProperty != 0 {
15705- if symbol.CheckFlags&ast.CheckFlagsDeferredType != 0 {
15706- return c.getWriteTypeOfSymbolWithDeferredType(symbol)
15707- }
15708- links := c.valueSymbolLinks.Get(symbol)
15709- return core.OrElse(links.writeType, links.resolvedType)
15716+ if symbol.CheckFlags&ast.CheckFlagsSyntheticProperty != 0 {
15717+ if symbol.CheckFlags&ast.CheckFlagsDeferredType != 0 {
15718+ return c.getWriteTypeOfSymbolWithDeferredType(symbol)
1571015719 }
15720+ links := c.valueSymbolLinks.Get(symbol)
15721+ return core.OrElse(links.writeType, links.resolvedType)
15722+ }
15723+ if symbol.Flags&ast.SymbolFlagsProperty != 0 {
1571115724 return c.removeMissingType(c.getTypeOfSymbol(symbol), symbol.Flags&ast.SymbolFlagsOptional != 0)
1571215725 }
1571315726 if symbol.Flags&ast.SymbolFlagsAccessor != 0 {
@@ -20598,6 +20611,7 @@ func (c *Checker) getUnionOrIntersectionProperty(t *Type, name string, skipObjec
2059820611}
2059920612
2060020613func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name string, skipObjectFunctionPropertyAugment bool) *ast.Symbol {
20614+ propFlags := ast.SymbolFlagsNone
2060120615 var singleProp *ast.Symbol
2060220616 var propSet collections.OrderedSet[*ast.Symbol]
2060320617 var indexTypes []*Type
@@ -20627,6 +20641,7 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s
2062720641 }
2062820642 if singleProp == nil {
2062920643 singleProp = prop
20644+ propFlags = core.OrElse(prop.Flags&ast.SymbolFlagsAccessor, ast.SymbolFlagsProperty)
2063020645 } else if prop != singleProp {
2063120646 isInstantiation := c.getTargetSymbol(prop) == c.getTargetSymbol(singleProp)
2063220647 // If the symbols are instances of one another with identical types - consider the symbols
@@ -20643,6 +20658,13 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s
2064320658 }
2064420659 propSet.Add(prop)
2064520660 }
20661+ // classes created by mixins are represented as intersections
20662+ // and overriding a property in a derived class redefines it completely at runtime
20663+ // so a get accessor can't be merged with a set accessor in a base class,
20664+ // for that reason the accessor flags are only used when they are the same in all constituents
20665+ if propFlags&ast.SymbolFlagsAccessor != 0 && (prop.Flags&ast.SymbolFlagsAccessor != (propFlags & ast.SymbolFlagsAccessor)) {
20666+ propFlags = (propFlags &^ ast.SymbolFlagsAccessor) | ast.SymbolFlagsProperty
20667+ }
2064620668 }
2064720669 if isUnion && c.isReadonlySymbol(prop) {
2064820670 checkFlags |= ast.CheckFlagsReadonly
@@ -20670,6 +20692,7 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s
2067020692 indexInfo = c.getApplicableIndexInfoForName(t, name)
2067120693 }
2067220694 if indexInfo != nil {
20695+ propFlags = propFlags&^ast.SymbolFlagsAccessor | ast.SymbolFlagsProperty
2067320696 checkFlags |= ast.CheckFlagsWritePartial | (core.IfElse(indexInfo.isReadonly, ast.CheckFlagsReadonly, 0))
2067420697 if isTupleType(t) {
2067520698 indexType := c.getRestTypeOfTupleType(t)
@@ -20762,7 +20785,7 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s
2076220785 propTypes = append(propTypes, t)
2076320786 }
2076420787 propTypes = append(propTypes, indexTypes...)
20765- result := c.newSymbolEx(ast.SymbolFlagsProperty |optionalFlag, name, checkFlags|syntheticFlag)
20788+ result := c.newSymbolEx(propFlags |optionalFlag, name, checkFlags|syntheticFlag)
2076620789 result.Declarations = declarations
2076720790 if !hasNonUniformValueDeclaration && firstValueDeclaration != nil {
2076820791 result.ValueDeclaration = firstValueDeclaration
@@ -23059,6 +23082,8 @@ func (c *Checker) computeEnumMemberValues(node *ast.Node) {
2305923082func (c *Checker) computeEnumMemberValue(member *ast.Node, autoValue jsnum.Number, previous *ast.Node) evaluator.Result {
2306023083 if ast.IsComputedNonLiteralName(member.Name()) {
2306123084 c.error(member.Name(), diagnostics.Computed_property_names_are_not_allowed_in_enums)
23085+ } else if ast.IsBigIntLiteral(member.Name()) {
23086+ c.error(member.Name(), diagnostics.An_enum_member_cannot_have_a_numeric_name)
2306223087 } else {
2306323088 text := ast.GetTextOfPropertyName(member.Name())
2306423089 if isNumericLiteralName(text) && !isInfinityOrNaNString(text) {
0 commit comments