fix(core): cross stack references to string lists break

packages/@aws-cdk/aws-ec2/test/integ.core-cross-stack-string-list-references.ts

@@ -0,0 +1,72 @@
+import * as ssm from '@aws-cdk/aws-ssm';
+import { App, CfnParameter, Stack, StackProps } from '@aws-cdk/core';
+import { IntegTest } from '@aws-cdk/integ-tests';
+import { Construct } from 'constructs';
+import { InterfaceVpcEndpoint, InterfaceVpcEndpointAwsService, Vpc } from '../lib';
+
+// GIVEN
+const app = new App({
+  treeMetadata: false,
+});
+
+class ProducerStack extends Stack {
+  public stringListGetAtt: string[];
+  public stringListRef: CfnParameter;
+  public manualExport: string[];
+
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    const vpc = new Vpc(this, 'vpc');
+    this.stringListGetAtt = new InterfaceVpcEndpoint(this, 'endpoint', {
+      vpc,
+      service: InterfaceVpcEndpointAwsService.SECRETS_MANAGER,
+    }).vpcEndpointDnsEntries;
+
+    this.stringListRef = new CfnParameter(this, 'stringListParam', {
+      default: 'BLAT,BLAH',
+      type: 'List<String>',
+    });
+
+    this.manualExport = this.exportListValue(['string1', 'string2'], {
+      name: 'ManualExport',
+    });
+  }
+}
+
+export interface consumerDeployProps extends StackProps {
+  stringListGetAtt: string[],
+  stringListRef: CfnParameter,
+  manualStringList: string[]
+}
+
+class ConsumerStack extends Stack {
+  constructor(scope: Construct, id: string, props: consumerDeployProps) {
+    super(scope, id, props);
+
+    new ssm.StringListParameter(this, 'GetAtt', {
+      stringListValue: props.stringListGetAtt,
+    });
+
+    new ssm.StringListParameter(this, 'Ref', {
+      stringListValue: props.stringListRef.valueAsList,
+    });
+
+    new ssm.StringListParameter(this, 'Manual', {
+      stringListValue: props.manualStringList,
+    });
+  }
+}
+
+const producer = new ProducerStack(app, 'producer');
+const consumer = new ConsumerStack(app, 'consumer', {
+  stringListGetAtt: producer.stringListGetAtt,
+  stringListRef: producer.stringListRef,
+  manualStringList: producer.manualExport,
+});
+
+// THEN
+new IntegTest(app, 'cross-region-references', {
+  testCases: [producer, consumer],
+  stackUpdateWorkflow: false,
+});

packages/@aws-cdk/aws-ec2/test/vpc.test.ts

@@ -1,6 +1,6 @@
 import { Annotations, Match, Template } from '@aws-cdk/assertions';
 import { testDeprecated } from '@aws-cdk/cdk-build-tools';
-import { CfnOutput, CfnResource, Fn, Lazy, Stack, Tags } from '@aws-cdk/core';
+import { App, CfnOutput, CfnResource, Fn, Lazy, Stack, Tags } from '@aws-cdk/core';
 import {
   AclCidr,
   AclTraffic,
@@ -27,6 +27,7 @@ import {
   TrafficDirection,
   Vpc,
   IpAddresses,
+  InterfaceVpcEndpointAwsService,
 } from '../lib';
 
 describe('vpc', () => {
@@ -2115,6 +2116,66 @@ describe('vpc', () => {
       }
     });
   });
+
+  describe('can reference vpcEndpointDnsEntries across stacks', () => {
+    test('can reference an actual string list across stacks', () => {
+      const app = new App();
+      const stack1 = new Stack(app, 'Stack1');
+      const vpc = new Vpc(stack1, 'Vpc');
+      const endpoint = new InterfaceVpcEndpoint(stack1, 'interfaceVpcEndpoint', {
+        vpc,
+        service: InterfaceVpcEndpointAwsService.SECRETS_MANAGER,
+      });
+
+      const stack2 = new Stack(app, 'Stack2');
+      new CfnOutput(stack2, 'endpoint', {
+        value: Fn.select(0, endpoint.vpcEndpointDnsEntries),
+      });
+
+      const assembly = app.synth();
+      const template1 = assembly.getStackByName(stack1.stackName).template;
+      const template2 = assembly.getStackByName(stack2.stackName).template;
+
+      // THEN
+      expect(template1).toMatchObject({
+        Outputs: {
+          ExportsOutputFnGetAttinterfaceVpcEndpoint89C99945DnsEntriesB1872F7A: {
+            Value: {
+              'Fn::Join': [
+                '||', {
+                  'Fn::GetAtt': [
+                    'interfaceVpcEndpoint89C99945',
+                    'DnsEntries',
+                  ],
+                },
+              ],
+            },
+            Export: { Name: 'Stack1:ExportsOutputFnGetAttinterfaceVpcEndpoint89C99945DnsEntriesB1872F7A' },
+          },
+        },
+      });
+
+      expect(template2).toMatchObject({
+        Outputs: {
+          endpoint: {
+            Value: {
+              'Fn::Select': [
+                0,
+                {
+                  'Fn::Split': [
+                    '||',
+                    {
+                      'Fn::ImportValue': 'Stack1:ExportsOutputFnGetAttinterfaceVpcEndpoint89C99945DnsEntriesB1872F7A',
+                    },
+                  ],
+                },
+              ],
+            },
+          },
+        },
+      });
+    });
+  });
 });
 
 function getTestStack(): Stack {

packages/@aws-cdk/aws-iam/lib/util.ts

@@ -1,4 +1,4 @@
-import { captureStackTrace, DefaultTokenResolver, IPostProcessor, IResolvable, IResolveContext, Lazy, StringConcat, Token, Tokenization } from '@aws-cdk/core';
+import { captureStackTrace, DefaultTokenResolver, IPostProcessor, IResolvable, IResolveContext, Lazy, ResolutionTypeHint, StringConcat, Token, Tokenization } from '@aws-cdk/core';
 import { IConstruct } from 'constructs';
 import { IPolicy } from './policy';
 
@@ -112,9 +112,11 @@ export class UniqueStringSet implements IResolvable, IPostProcessor {
   }
 
   public readonly creationStack: string[];
+  public readonly typeHint: ResolutionTypeHint;
 
   private constructor(private readonly fn: () => string[]) {
     this.creationStack = captureStackTrace();
+    this.typeHint = ResolutionTypeHint.LIST;
   }
 
   public resolve(context: IResolveContext) {

packages/@aws-cdk/aws-ssm/lib/parameter.ts

@@ -729,7 +729,7 @@ export class StringListParameter extends ParameterBase implements IStringListPar
       name: this.physicalName,
       tier: props.tier,
       type: ParameterType.STRING_LIST,
-      value: props.stringListValue.join(','),
+      value: Fn.join(',', props.stringListValue),
     });
     this.parameterName = this.getResourceNameAttribute(resource.ref);
     this.parameterArn = arnForParameterName(this, this.parameterName, {

packages/@aws-cdk/aws-stepfunctions/lib/private/json-path.ts

@@ -1,4 +1,4 @@
-import { captureStackTrace, IResolvable, IResolveContext, Token, Tokenization } from '@aws-cdk/core';
+import { captureStackTrace, IResolvable, IResolveContext, ResolutionTypeHint, Token, Tokenization } from '@aws-cdk/core';
 import { IntrinsicParser, IntrinsicExpression } from './intrinstics';
 
 const JSON_PATH_TOKEN_SYMBOL = Symbol.for('@aws-cdk/aws-stepfunctions.JsonPathToken');
@@ -9,10 +9,12 @@ export class JsonPathToken implements IResolvable {
   }
 
   public readonly creationStack: string[];
+  public readonly typeHint: ResolutionTypeHint;
   public displayHint: string;
 
   constructor(public readonly path: string) {
     this.creationStack = captureStackTrace();
+    this.typeHint = ResolutionTypeHint.STRING;
     this.displayHint = path.replace(/^[^a-zA-Z]+/, '');
     Object.defineProperty(this, JSON_PATH_TOKEN_SYMBOL, { value: true });
   }

packages/@aws-cdk/core/lib/cfn-fn.ts

@@ -6,6 +6,7 @@ import { IResolvable, IResolveContext } from './resolvable';
 import { Stack } from './stack';
 import { captureStackTrace } from './stack-trace';
 import { Token } from './token';
+import { ResolutionTypeHint } from './type-hints';
 
 /* eslint-disable max-len */
 
@@ -810,6 +811,7 @@ class FnValueOfAll extends FnBase {
  */
 class FnJoin implements IResolvable {
   public readonly creationStack: string[];
+  public readonly typeHint: ResolutionTypeHint;
 
   private readonly delimiter: string;
   private readonly listOfValues: any[];
@@ -828,6 +830,7 @@ class FnJoin implements IResolvable {
     this.delimiter = delimiter;
     this.listOfValues = listOfValues;
     this.creationStack = captureStackTrace();
+    this.typeHint = ResolutionTypeHint.STRING;
   }
 
   public resolve(context: IResolveContext): any {
@@ -867,12 +870,14 @@ class FnJoin implements IResolvable {
  */
 class FnToJsonString implements IResolvable {
   public readonly creationStack: string[];
+  public readonly typeHint: ResolutionTypeHint;
 
   private readonly object: any;
 
   constructor(object: any) {
     this.object = object;
     this.creationStack = captureStackTrace();
+    this.typeHint = ResolutionTypeHint.STRING;
   }
 
   public resolve(context: IResolveContext): any {
@@ -895,12 +900,14 @@ class FnToJsonString implements IResolvable {
  */
 class FnLength implements IResolvable {
   public readonly creationStack: string[];
+  public readonly typeHint: ResolutionTypeHint;
 
   private readonly array: any;
 
   constructor(array: any) {
     this.array = array;
     this.creationStack = captureStackTrace();
+    this.typeHint = ResolutionTypeHint.NUMBER;
   }
 
   public resolve(context: IResolveContext): any {

packages/@aws-cdk/core/lib/cfn-mapping.ts

@@ -130,7 +130,7 @@ export class CfnMapping extends CfnRefElement {
 class CfnMappingEmbedder implements IResolvable {
   readonly creationStack: string[] = [];
 
-  constructor(private readonly cfnMapping: CfnMapping, readonly mapping: Mapping, private readonly key1: string, private readonly key2: string) { }
+  constructor(private readonly cfnMapping: CfnMapping, readonly mapping: Mapping, private readonly key1: string, private readonly key2: string) {}
 
   public resolve(context: IResolveContext): string {
     const consumingStack = Stack.of(context.scope);

packages/@aws-cdk/core/lib/cfn-output.ts

@@ -51,6 +51,10 @@ export class CfnOutput extends CfnElement {
 
     if (props.value === undefined) {
       throw new Error(`Missing value for CloudFormation output at path "${this.node.path}"`);
+    } else if (Array.isArray(props.value)) {
+      // `props.value` is a string, but because cross-stack exports allow passing any,
+      // we need to check for lists here.
+      throw new Error(`CloudFormation output was given a string list instead of a string or number at path "${this.node.path}"`);
     }
 
     this._description = props.description;

packages/@aws-cdk/core/lib/cfn-parameter.ts

@@ -3,6 +3,7 @@ import { CfnElement } from './cfn-element';
 import { CfnReference } from './private/cfn-reference';
 import { IResolvable, IResolveContext } from './resolvable';
 import { Token } from './token';
+import { ResolutionTypeHint } from './type-hints';
 
 export interface CfnParameterProps {
   /**
@@ -108,6 +109,7 @@ export class CfnParameter extends CfnElement {
   private _minLength?: number;
   private _minValue?: number;
   private _noEcho?: boolean;
+  private typeHint: ResolutionTypeHint;
 
   /**
    * Creates a parameter construct.
@@ -131,6 +133,7 @@ export class CfnParameter extends CfnElement {
     this._minLength = props.minLength;
     this._minValue = props.minValue;
     this._noEcho = props.noEcho;
+    this.typeHint = typeToTypeHint(this._type);
   }
 
   /**
@@ -144,6 +147,7 @@ export class CfnParameter extends CfnElement {
 
   public set type(type: string) {
     this._type = type;
+    this.typeHint = typeToTypeHint(this._type);
   }
 
   /**
@@ -282,7 +286,7 @@ export class CfnParameter extends CfnElement {
    * The parameter value as a Token
    */
   public get value(): IResolvable {
-    return CfnReference.for(this, 'Ref');
+    return CfnReference.for(this, 'Ref', undefined, this.typeHint);
   }
 
   /**
@@ -363,3 +367,13 @@ function isNumberType(type: string) {
 function isStringType(type: string) {
   return !isListType(type) && !isNumberType(type);
 }
+
+function typeToTypeHint(type: string): ResolutionTypeHint {
+  if (isListType(type)) {
+    return ResolutionTypeHint.LIST;
+  } else if (isNumberType(type)) {
+    return ResolutionTypeHint.NUMBER;
+  }
+
+  return ResolutionTypeHint.STRING;
+}

packages/@aws-cdk/core/lib/cfn-resource.ts

@@ -15,6 +15,7 @@ import { TagManager } from './tag-manager';
 import { Tokenization } from './token';
 import { capitalizePropertyNames, ignoreEmpty, PostResolveToken } from './util';
 import { FeatureFlags } from './feature-flags';
+import { ResolutionTypeHint } from './type-hints';
 
 export interface CfnResourceProps {
   /**
@@ -172,8 +173,8 @@ export class CfnResource extends CfnRefElement {
    * in case there is no generated attribute.
    * @param attributeName The name of the attribute.
    */
-  public getAtt(attributeName: string): Reference {
-    return CfnReference.for(this, attributeName);
+  public getAtt(attributeName: string, typeHint?: ResolutionTypeHint): Reference {
+    return CfnReference.for(this, attributeName, undefined, typeHint);
   }
 
   /**

packages/@aws-cdk/core/lib/index.ts

@@ -3,6 +3,7 @@ export * from './tag-aspect';
 
 export * from './token';
 export * from './resolvable';
+export * from './type-hints';
 export * from './lazy';
 export * from './tag-manager';
 export * from './string-fragments';