Merge branch 'master' of github.com:PolymerLabs/arcs into r2p-tests

Author: alxmrs

src/runtime/manifest-ast-nodes.ts

@@ -378,7 +378,7 @@ export interface RecipeRequire extends BaseNode {
   items: RecipeItem[];
 }
 
-export type RecipeItem = RecipeParticle | RecipeHandle | RequireHandleSection | RecipeRequire | RecipeSlot | RecipeSearch | RecipeConnection | Description;
+export type RecipeItem = RecipeParticle | RecipeHandle | RecipeSyntheticHandle | RequireHandleSection | RecipeRequire | RecipeSlot | RecipeSearch | RecipeConnection | Description;
 
 export const RELAXATION_KEYWORD = 'someof';
 
@@ -413,6 +413,12 @@ export interface RecipeHandle extends BaseNode {
   annotation: ParameterizedAnnotation|null;
 }
 
+export interface RecipeSyntheticHandle extends BaseNode {
+  kind: 'synthetic-handle';
+  name: string|null;
+  associations: string[];
+}
+
 export interface RecipeParticleSlotConnection extends BaseNode {
   kind: 'slot-connection';
   param: string;
@@ -760,7 +766,7 @@ export function preSlandlesDirectionToDirection(direction: Direction, isOptional
 }
 
 export type SlotDirection = 'provides' | 'consumes';
-export type Fate = 'use' | 'create' | 'map' | 'copy' | '?' | '`slot';
+export type Fate = 'use' | 'create' | 'map' | 'copy' | 'join' | '?' | '`slot';
 
 export type ParticleHandleConnectionType = TypeVariable|CollectionType|
     BigCollectionType|ReferenceType|SlotType|SchemaInline|TypeName;

src/runtime/manifest-parser.pegjs

@@ -836,6 +836,7 @@ RecipeNode
 RecipeItem
   = RecipeParticle
   / RecipeHandle
+  / RecipeSyntheticHandle
   / RequireHandleSection
   / RecipeRequire
   / RecipeSlot
@@ -1079,6 +1080,16 @@ RecipeHandle
     });
   }
 
+RecipeSyntheticHandle
+  = name:NameWithColon? 'join' whiteSpace '(' whiteSpace? first:lowerIdent rest:(whiteSpace? ',' whiteSpace? lowerIdent)* ')' eolWhiteSpace
+  {
+    return toAstNode<AstNode.RecipeSyntheticHandle>({
+      kind: 'synthetic-handle',
+      name,
+      associations: [first].concat(rest.map(t => t[3])),
+    });
+  }
+
 RecipeRequire
   = 'require' eolWhiteSpace items:(Indent (SameIndent (RecipeParticle / RequireHandleSection / RecipeSlot))*)?
   {

src/runtime/manifest.ts

@@ -791,7 +791,8 @@ ${e.message}
     const items = {
       require: recipeItems.filter(item => item.kind === 'require') as AstNode.RecipeRequire[],
       handles: recipeItems.filter(item => item.kind === 'handle') as AstNode.RecipeHandle[],
-      byHandle: new Map<Handle, AstNode.RecipeHandle | AstNode.RequireHandleSection>(),
+      syntheticHandles: recipeItems.filter(item => item.kind === 'synthetic-handle') as AstNode.RecipeSyntheticHandle[],
+      byHandle: new Map<Handle, AstNode.RecipeHandle | AstNode.RecipeSyntheticHandle | AstNode.RequireHandleSection>(),
       // requireHandles are handles constructed by the 'handle' keyword. This is intended to replace handles.
       requireHandles: recipeItems.filter(item => item.kind === 'requireHandle') as AstNode.RequireHandleSection[],
       particles: recipeItems.filter(item => item.kind === 'recipe-particle') as AstNode.RecipeParticle[],
@@ -844,6 +845,27 @@ ${e.message}
       items.byHandle.set(handle, item);
     }
 
+    for (const item of items.syntheticHandles) {
+      const handle = recipe.newHandle();
+      handle.fate = 'join';
+      
+      if (item.name) {
+        assert(!items.byName.has(item.name), `duplicate handle name: ${item.name}`);
+        handle.localName = item.name;
+        items.byName.set(item.name, {item, handle});
+      }
+
+      for (const association of item.associations) {
+        const associatedItem = items.byName.get(association);
+        assert(associatedItem, `unrecognized name: ${association}`);
+        const associatedHandle = associatedItem && associatedItem.handle;
+        assert(associatedHandle, `only handles allowed to be joined: "${association}" is not a handle`);
+        handle.associateHandle(associatedHandle);
+      }
+
+      items.byHandle.set(handle, item);
+    }
+
     const prepareEndpoint = (connection, info) => {
       switch (info.targetType) {
         case 'particle': {

src/runtime/recipe/handle.ts

@@ -36,6 +36,7 @@ export class Handle implements Comparable<Handle> {
   private _originalFate: Fate | null = null;
   private _originalId: string | null = null;
   private _connections: HandleConnection[] = [];
+  private _associatedHandles: Handle[] = [];
   private _mappedType: Type | undefined = undefined;
   private _storageKey: StorageKey | undefined = undefined;
   capabilities: Capabilities;
@@ -102,6 +103,7 @@ export class Handle implements Comparable<Handle> {
       // attached HandleConnection objects.
       handle._connections = [];
       handle._pattern = this._pattern;
+      handle._associatedHandles = this._associatedHandles.map(h => cloneMap.get(h) as Handle);
     }
     return handle;
   }
@@ -123,7 +125,7 @@ export class Handle implements Comparable<Handle> {
   _mergedFate(fates: Fate[]) {
     assert(fates.length > 0, `Cannot merge empty fates list`);
     // Merging handles only used in coalesce-recipe strategy, which is only done for use/create/? fates.
-    assert(!fates.includes('map') && !fates.includes('copy'), `Merging map/copy not supported yet`);
+    assert(!fates.some(f => f === 'map' || f === 'copy' || f === 'join'), `Merging map/copy/join not supported yet`);
 
     // If all fates were `use` keep their fate, otherwise set to `create`.
     return fates.every(fate => fate === 'use') ? 'use' : 'create';
@@ -206,6 +208,7 @@ export class Handle implements Comparable<Handle> {
   get localName() { return this._localName; }
   set localName(name: string) { this._localName = name; }
   get connections() { return this._connections; } // HandleConnection*
+  get associatedHandles() { return this._associatedHandles; }
   get storageKey() { return this._storageKey; }
   set storageKey(key: StorageKey) { this._storageKey = key; }
   get pattern() { return this._pattern; }
@@ -216,6 +219,7 @@ export class Handle implements Comparable<Handle> {
   set immediateValue(value: ParticleSpec) { this._immediateValue = value; }
   get ttl() { return this._ttl; }
   set ttl(ttl: Ttl) { this._ttl = ttl; }
+  get isSynthetic() { return this.fate === 'join'; } // Join handles are the first type of synthetic handles, other may come.
 
   static effectiveType(handleType: Type, connections: {type?: Type, direction?: Direction, relaxed?: boolean}[]) {
     const variableMap = new Map<TypeVariableInfo|Schema, TypeVariableInfo|Schema>();
@@ -332,13 +336,17 @@ export class Handle implements Comparable<Handle> {
       // E.g. hostedParticle = ShowProduct
       return undefined;
     }
+    const getName = (h:Handle) => ((nameMap && nameMap.get(h)) || h.localName);
     // TODO: type? maybe output in a comment
     const result: string[] = [];
-    const name = (nameMap && nameMap.get(this)) || this.localName;
+    const name = getName(this);
     if (name) {
       result.push(`${name}:`);
     }
     result.push(this.fate);
+    if (this.associatedHandles.length) {
+      result.push(`(${this.associatedHandles.map(h => getName(h)).join(', ')})`);
+    }
     if (this.capabilities && !this.capabilities.isEmpty()) {
       result.push(this.capabilities.toString());
     }
@@ -376,4 +384,9 @@ export class Handle implements Comparable<Handle> {
   findConnectionByDirection(dir: Direction): HandleConnection|undefined {
     return this._connections.find(conn => conn.direction === dir);
   }
+
+  associateHandle(handle: Handle) {
+    assert(this.fate === 'join');
+    this._associatedHandles.push(handle);
+  }
 }

src/runtime/recipe/recipe.ts

@@ -540,7 +540,10 @@ export class Recipe implements Cloneable<Recipe> {
 
     recipe._name = this.name;
     recipe._verbs = recipe._verbs.concat(...this._verbs);
-    this._handles.forEach(cloneTheThing);
+
+    // Clone regular handles first, then synthetic ones, as synthetic can depend on regular.
+    this._handles.filter(h => !h.isSynthetic).forEach(cloneTheThing);
+    this._handles.filter(h => h.isSynthetic).forEach(cloneTheThing);
     this._particles.forEach(cloneTheThing);
     this._slots.forEach(cloneTheThing);
     this._connectionConstraints.forEach(cloneTheThing);

src/runtime/tests/manifest-parser-test.ts

@@ -57,6 +57,13 @@ describe('manifest parser', () => {
         h1: create 'my-id' #anotherTag @ttl(1h)
         h2: create @ttl ( 30m )`);
   });
+  it('parses recipes with a synthetic join handles', () => {
+    parse(`
+      recipe
+        people: map #folks
+        places: map #locations
+        pairs: join (people, places)`);
+  });
   it('parses recipe handles with capabilities', () => {
     parse(`
       recipe Thing

src/runtime/tests/manifest-test.ts

@@ -311,6 +311,43 @@ ${particleStr1}
 
     assert.notStrictEqual(manifestA.stores[0].id.toString(), manifestB.stores[0].id.toString());
   });
+  it('can parse a recipe with a synthetic join handle', async () => {
+    const manifest = await parseManifest(`
+      recipe
+        people: map #folks
+        other: map #products
+        pairs: join (people, places)
+        places: map #locations`);
+    const verify = (manifest: Manifest) => {
+      const [recipe] = manifest.recipes;
+      assert.lengthOf(recipe.handles, 4);
+      const people = recipe.handles.find(h => h.tags.includes('folks'));
+      assert.equal(people.fate, 'map');
+      const places = recipe.handles.find(h => h.tags.includes('locations'));
+      assert.equal(places.fate, 'map');
+
+      const pairs = recipe.handles.find(h => h.fate === 'join');
+      assert.equal(pairs.fate, 'join');
+      assert.lengthOf(pairs.associatedHandles, 2);
+
+      assert.include(pairs.associatedHandles, people);
+      assert.include(pairs.associatedHandles, places);
+    };
+    verify(manifest);
+    verify(await parseManifest(manifest.toString()));
+  });
+  it('fails to parse a recipe with an invalid synthetic join handle', async () => {
+    try {
+      await parseManifest(`
+        recipe
+          people: map #folks
+          things: map #products
+          pairs: join (people, locations)`);
+      assert.fail();
+    } catch (e) {
+      assert.include(e.message, 'unrecognized name: locations');
+    }
+  });
   it('supports recipes with constraints', async () => {
     const manifest = await parseManifest(`
       schema S

src/runtime/tests/recipe-test.ts

@@ -12,11 +12,10 @@ import {assert} from '../../platform/chai-web.js';
 import {Loader} from '../../platform/loader.js';
 import {Manifest} from '../manifest.js';
 import {Modality} from '../modality.js';
-import {Type} from '../type.js';
 import {Capabilities} from '../capabilities.js';
-import {Flags} from '../flags.js';
 import {Entity} from '../entity.js';
 import {TtlUnits, Ttl} from '../recipe/ttl.js';
+import {Recipe} from '../recipe/recipe.js';
 import {TestVolatileMemoryProvider} from '../testing/test-volatile-memory-provider.js';
 import {RamDiskStorageDriverProvider} from '../storageNG/drivers/ramdisk.js';
 
@@ -838,4 +837,34 @@ describe('recipe', () => {
     assert.isFalse(recipes[2].isLongRunning);
     assert.isTrue(recipes[3].isLongRunning);
   });
+  it('can normalize and clone a recipe with a synthetic join handle', async () => {
+    const [recipe] = (await Manifest.parse(`
+      recipe
+        people: map #folks
+        other: map #products
+        pairs: join (people, places)
+        places: map #locations`)).recipes;
+
+    const verify = (recipe: Recipe) => {
+      assert.lengthOf(recipe.handles, 4);
+      const people = recipe.handles.find(h => h.tags.includes('folks'));
+      assert.equal(people.fate, 'map');
+      const places = recipe.handles.find(h => h.tags.includes('locations'));
+      assert.equal(places.fate, 'map');
+
+      const pairs = recipe.handles.find(h => h.fate === 'join');
+      assert.equal(pairs.fate, 'join');
+      assert.lengthOf(pairs.associatedHandles, 2);
+
+      assert.include(pairs.associatedHandles, people);
+      assert.include(pairs.associatedHandles, places);
+    };
+
+    verify(recipe);
+
+    recipe.normalize();
+    verify(recipe);
+
+    verify(recipe.clone());
+  });
 });