// The antlr parser generator fragment.
			fragment = parser.antlr.ex.rt.AntlrGeneratorFragment auto-inject {
				options = {
					ignoreCase = true
				}
			}

BSSelectionExpression returns BSExpression:
	BSTerminalExpression
	({BSMemberSelection.receiver=current} '.'
	member=[BSMember]
	(methodinvocation?='('
	(args+=BSExpression (',' args+=BSExpression)*)? ')')?)*
;

BSTerminalExpression returns BSExpression:
	...
	{BSSymbolRef} symbol=[BSSymbol] (methodinvocation?='('(args+=BSExpression (',' args+=BSExpression)*)? ')')?

BSSymbol:
	BSVariableDeclaration | BSParameter | BSMember
;

	@Test def void testCrossLinkingWithMemberAsSymbol() {
		'''
		class R { V vv; }
		class P extends R {
			R m() { return null; }
		}
		class N extends R {}
		class V extends R {}
		
		class C extends R {
			R m(P pp) {
				return pp.m().vv;
			}
		}
		'''.parse => [
			assertEquals("V", classes.head.fields.head.type.name); //passes: R's vv is of type V
			assertEquals("R", classes.get(1).methods.head.type.name); //passes: P's m() is of type R
			
			//C.m()'s pp.m().vv is a member of the type returned by pp.m(). We know the member selection m() to be non-null,
			//because the following assertion on its return type passes:
			assertEquals("R", (((classes.last.methods.head.body.statements.head as BSReturn)
				.expression as BSMemberSelection).receiver as BSMemberSelection).member.type.name)
				
			//The pp.m() selection is very definitely pointing to the correct R:
			assertSame(classes.get(0),  (((classes.last.methods.head.body.statements.head as BSReturn)
				.expression as BSMemberSelection).receiver as BSMemberSelection).member.type)
				
			//The type EObject of pp.m().vv should be an object with a toString resembling this:
					//org.xtext.example.blorquescript.blorqueScript.impl.BSClass@00000000 (name: V)
			//but it's actually null; the following assertion fails:
			assertNotNull(((classes.last.methods.head.body.statements.head as BSReturn).expression as BSMemberSelection).member.type)
			//This is because the member itself seems to be "synthetic", which I take to mean,
			//the linker never found R.vv when it was deciding what pp.m().vv was referring to.
			
			assertNoErrors //fails: Couldn't resolve reference to BSMember 'vv' on the BSMemberSelection
		]
	}

	@Test def void testVariableShadowsParamLinking() {
		'''
		class C {
			A m(A a) {
				A a = null;
				return a;
			}	
		}
		class A {}
		'''.parse.classes.head.methods.head => [
				System.out.println(body.statements.head.getScope(BlorqueScriptPackage::eINSTANCE.BSSymbolRef_Symbol).allElements.map[name].join(", "))
				returnStatements.last.expression.assertScope(BlorqueScriptPackage::eINSTANCE.BSSymbolRef_Symbol,
					"a, a, m, m.a, m.a, C.m, C.m.a, C.m.a"
					//This was coming up "a, a, m.a, m.a, C.m.a, C.m.a" until I added basic custom scoping as per Bettini p. 242
				)
				body.statements.head.assertSame(
					(returnStatements.last.expression as BSSymbolRef).symbol
					//fails: This symbol should be the declaration, but is instead the parameter.
					//  my custom scoping didn't help even though it passes into scopeFor first the statement and then the parameter,
					//  as in Mr. Bettini's book.
				)
		]
	}

BSField:
  //This part was deleted: access=SJAccessLevel?
  type=[BSClass|QualifiedName] name=ID ';'
;
BSMethod:
  //This part was deleted: access=SJAccessLevel?
  type=[BSClass|QualifiedName] name=ID
  '(' (params+=BSParameter (',' params+=BSParameter)*)? ')'
  body=BSMethodBody
;

//the rule below was deleted:
enum SJAccessLevel:
PRIVATE='private' | PUBLIC='public' | PROTECTED='protected';

class BlorqueScriptScopeProvider extends AbstractDeclarativeScopeProvider {
	def scope_BSSymbolRef_symbol(BSExpression context, EReference ref) {
		context.symbolsDefinedBefore(context)
	}
	
	def dispatch IScope symbolsDefinedBefore(EObject context, EObject obj) {
		context.eContainer.symbolsDefinedBefore(obj.eContainer)
	}
	
	def dispatch IScope symbolsDefinedBefore(BSMethod context, EObject obj) {
		Scopes::scopeFor(context.params)
	}

	def dispatch IScope symbolsDefinedBefore(BSBlock context, EObject obj) {
		Scopes::scopeFor(
			context.statements.variablesDeclaredBefore(obj),
			context.eContainer.symbolsDefinedBefore(obj.eContainer)
		)
	}
	
	//-- PRIVATE HELPERS --//
	def private variablesDeclaredBefore(List<BSStatement> list, EObject obj) {
		list.subList(0, list.indexOf(obj)).filter(typeof(BSVariableDeclaration))
	}
}