Changed Name IntersectionWithDefaultDynamicReferenceType -> ReferenceTypeWithDefault

Author: markwpearce

src/astUtils/reflection.ts

@@ -23,7 +23,7 @@ import type { ObjectType } from '../types/ObjectType';
 import type { AstNode, Expression, Statement } from '../parser/AstNode';
 import type { AssetFile } from '../files/AssetFile';
 import { AstNodeKind } from '../parser/AstNode';
-import type { TypePropertyReferenceType, ReferenceType, BinaryOperatorReferenceType, ArrayDefaultTypeReferenceType, AnyReferenceType, ParamTypeFromValueReferenceType, IntersectionWithDefaultDynamicReferenceType } from '../types/ReferenceType';
+import type { TypePropertyReferenceType, ReferenceType, BinaryOperatorReferenceType, ArrayDefaultTypeReferenceType, AnyReferenceType, ParamTypeFromValueReferenceType, ReferenceTypeWithDefault } from '../types/ReferenceType';
 import type { EnumMemberType, EnumType } from '../types/EnumType';
 import type { UnionType } from '../types/UnionType';
 import type { UninitializedType } from '../types/UninitializedType';
@@ -458,8 +458,8 @@ export function isArrayDefaultTypeReferenceType(value: any): value is ArrayDefau
 export function isParamTypeFromValueReferenceType(value: any): value is ParamTypeFromValueReferenceType {
     return value?.__reflection?.name === 'ParamTypeFromValueReferenceType';
 }
-export function isIntersectionWithDefaultDynamicReferenceType(value: any): value is IntersectionWithDefaultDynamicReferenceType {
-    return value?.__reflection?.name === 'IntersectionWithDefaultDynamicReferenceType';
+export function isReferenceTypeWithDefault(value: any): value is ReferenceTypeWithDefault {
+    return value?.__reflection?.name === 'ReferenceTypeWithDefault';
 }
 export function isNamespaceType(value: any): value is NamespaceType {
     return value?.kind === BscTypeKind.NamespaceType;
@@ -497,7 +497,7 @@ export function isCallableType(target): target is BaseFunctionType {
 
 export function isAnyReferenceType(target): target is AnyReferenceType {
     const name = target?.__reflection?.name;
-    return name === 'ReferenceType' || name === 'TypePropertyReferenceType' || name === 'BinaryOperatorReferenceType' || name === 'ArrayDefaultTypeReferenceType' || name === 'ParamTypeFromValueReferenceType' || name === 'IntersectionWithDefaultDynamicReferenceType';
+    return name === 'ReferenceType' || name === 'TypePropertyReferenceType' || name === 'BinaryOperatorReferenceType' || name === 'ArrayDefaultTypeReferenceType' || name === 'ParamTypeFromValueReferenceType' || name === 'ReferenceTypeWithDefault';
 }
 
 export function isNumberType(value: any): value is IntegerType | LongIntegerType | FloatType | DoubleType | InterfaceType {

src/parser/Parser.ts

@@ -3114,6 +3114,7 @@ export class Parser {
             if (this.match(TokenKind.LeftCurlyBrace)) {
                 expr = this.inlineInterface();
             } else if (this.match(TokenKind.LeftParen)) {
+                // this is a grouping type expression, ie. "(typeExpr)"
                 let left = this.previous();
                 let typeExpr = this.typeExpression();
                 let right = this.consume(

src/types/IntersectionType.ts

@@ -1,7 +1,7 @@
 import type { GetTypeOptions, TypeCompatibilityData } from '../interfaces';
 import { isDynamicType, isIntersectionType, isObjectType, isTypedFunctionType } from '../astUtils/reflection';
 import { BscType } from './BscType';
-import { IntersectionWithDefaultDynamicReferenceType, ReferenceType } from './ReferenceType';
+import { ReferenceTypeWithDefault, ReferenceType } from './ReferenceType';
 import { addAssociatedTypesTableAsSiblingToMemberTable, getAllTypesFromCompoundType, isEnumTypeCompatible, isTypeWithPotentialDefaultDynamicMember, joinTypesString, reduceTypesForIntersectionType } from './helpers';
 import { BscTypeKind } from './BscTypeKind';
 import type { TypeCacheEntry } from '../SymbolTable';
@@ -102,7 +102,7 @@ export class IntersectionType extends BscType {
         if (!innerTypesMemberType?.isResolvable()) {
             const shouldCreateDynamicAAMember = this.hasMemberTypeWithDefaultDynamicMember && !options.ignoreDefaultDynamicMembers;
             if (shouldCreateDynamicAAMember) {
-                return new IntersectionWithDefaultDynamicReferenceType(innerTypesMemberType);
+                return new ReferenceTypeWithDefault(innerTypesMemberType, DynamicType.instance);
             }
         }
         return innerTypesMemberType;
@@ -138,7 +138,7 @@ export class IntersectionType extends BscType {
         if (!resultCallFuncType?.isResolvable()) {
             const shouldCreateDynamicAAMember = this.hasMemberTypeWithDefaultDynamicMember && !options.ignoreDefaultDynamicMembers;
             if (shouldCreateDynamicAAMember) {
-                return new IntersectionWithDefaultDynamicReferenceType(resultCallFuncType);
+                return new ReferenceTypeWithDefault(resultCallFuncType, DynamicType.instance);
             }
         }
 

src/types/ReferenceType.ts

@@ -646,18 +646,18 @@ export class ParamTypeFromValueReferenceType extends BscType {
 
 /**
  * Used when an IntersectionType has at least one member that may have default dynamic members.
- * If the inner type is not resolvable, this type will resolve to DynamicType.
+ * If the inner type is not resolvable, this type will resolve to the given type DynamicType.
  */
-export class IntersectionWithDefaultDynamicReferenceType extends BscType {
-    constructor(public baseType: BscType) {
-        super('IntersectionWithDefaultDynamicReferenceType');
+export class ReferenceTypeWithDefault extends BscType {
+    constructor(public baseType: BscType, public defaultType: BscType) {
+        super('ReferenceTypeWithDefault');
         // eslint-disable-next-line no-constructor-return
         return new Proxy(this, {
             get: (target, propName, receiver) => {
 
                 if (propName === '__reflection') {
-                    // Cheeky way to get `isIntersectionWithDefaultDynamicReferenceType` reflection to work
-                    return { name: 'IntersectionWithDefaultDynamicReferenceType' };
+                    // Cheeky way to get `isReferenceTypeWithDefault` reflection to work
+                    return { name: 'ReferenceTypeWithDefault' };
                 }
 
                 if (propName === 'isResolvable') {
@@ -668,7 +668,7 @@ export class IntersectionWithDefaultDynamicReferenceType extends BscType {
                 let innerType = this.getTarget();
 
                 if (!innerType) {
-                    innerType = DynamicType.instance;
+                    innerType = this.defaultType;
                 }
 
                 if (innerType) {