static bool CheckAndDeduceTypeTuple(TemplateTupleParameter tupleParameter,
IEnumerable <ISemantic> typeChain,
DeducedTypeDictionary deducedTypes,
ResolutionContext ctxt)
{
return(new Templates.TemplateParameterDeduction(deducedTypes, ctxt).Handle(tupleParameter, typeChain));
}
public bool Handle(TemplateTupleParameter p, IEnumerable <ISemantic> arguments)
{
if (arguments == null)
{
return(false);
}
var args = arguments.ToArray();
if (args.Length < 1)
{
return(false);
}
var l = new List <AbstractType>();
foreach (var arg in arguments)
{
if (arg is AbstractType)
{
l.Add((AbstractType)arg);
}
else
{
// Error: Argument must be a type
break;
}
}
return(Set(p, new TypeTuple(p, l)));
}
public bool Handle(TemplateTupleParameter p, IEnumerable <ISemantic> arguments)
{
var l = new List <ISemantic>();
if (arguments != null)
{
foreach (var arg in arguments)
{
if (arg is DTuple) // If a type tuple was given already, add its items instead of the tuple itself
{
var tt = arg as DTuple;
if (tt.Items != null)
{
l.AddRange(tt.Items);
}
}
else
{
l.Add(arg);
}
}
}
return(Set(p, new DTuple(p, l.Count == 0 ? null : l), 0));
}
public virtual void Visit(TemplateTupleParameter p)
{
VisitTemplateParameter (p);
}
public bool Handle(TemplateTupleParameter p, IEnumerable<ISemantic> arguments)
{
var l = new List<ISemantic>();
if(arguments != null)
foreach (var arg in arguments)
if(arg is DTuple) // If a type tuple was given already, add its items instead of the tuple itself
{
var tt = arg as DTuple;
if(tt.Items != null)
l.AddRange(tt.Items);
}
else
l.Add(arg);
return Set(p, new DTuple(p, l.Count == 0 ? null : l), 0);
}
TemplateParameter TemplateParameter(DNode parent)
{
CodeLocation startLoc;
// TemplateThisParameter
if (laKind == (This))
{
Step();
startLoc = t.Location;
var end = t.EndLocation;
var ret= new TemplateThisParameter(TemplateParameter(parent), parent) { Location=startLoc, EndLocation=end };
LastParsedObject = ret;
return ret;
}
// TemplateTupleParameter
else if (laKind == (Identifier) && Lexer.CurrentPeekToken.Kind == TripleDot)
{
Step();
startLoc = t.Location;
var id = t.Value;
Step();
var ret=new TemplateTupleParameter(id, startLoc, parent) { Location=startLoc, EndLocation=t.EndLocation };
LastParsedObject = ret;
return ret;
}
// TemplateAliasParameter
else if (laKind == (Alias))
{
Step();
startLoc = t.Location;
TemplateAliasParameter al;
if(Expect(Identifier))
al = new TemplateAliasParameter(t.Value, t.Location, parent);
else
al = new TemplateAliasParameter(0, CodeLocation.Empty, parent);
al.Location = startLoc;
LastParsedObject = al;
// TODO?:
// alias BasicType Declarator TemplateAliasParameterSpecialization_opt TemplateAliasParameterDefault_opt
// TemplateAliasParameterSpecialization
if (laKind == (Colon))
{
Step();
AllowWeakTypeParsing=true;
al.SpecializationType = Type();
AllowWeakTypeParsing=false;
if (al.SpecializationType==null)
al.SpecializationExpression = ConditionalExpression();
}
// TemplateAliasParameterDefault
if (laKind == (Assign))
{
Step();
AllowWeakTypeParsing=true;
al.DefaultType = Type();
AllowWeakTypeParsing=false;
if (al.DefaultType==null)
al.DefaultExpression = ConditionalExpression();
}
al.EndLocation = t.EndLocation;
return al;
}
// TemplateTypeParameter
else if (laKind == (Identifier) && (Lexer.CurrentPeekToken.Kind == (Colon) || Lexer.CurrentPeekToken.Kind == (Assign) || Lexer.CurrentPeekToken.Kind == (Comma) || Lexer.CurrentPeekToken.Kind == (CloseParenthesis)))
{
Expect(Identifier);
var tt = new TemplateTypeParameter(t.Value, t.Location, parent) { Location = t.Location };
LastParsedObject = tt;
if (laKind == Colon)
{
Step();
tt.Specialization = Type();
}
if (laKind == Assign)
{
Step();
tt.Default = Type();
}
tt.EndLocation = t.EndLocation;
return tt;
}
// TemplateValueParameter
startLoc = la.Location;
var bt = BasicType();
var dv = Declarator(bt,false, null);
if (dv == null) {
SynErr (t.Kind, "Declarator expected for parsing template value parameter");
return null;
}
var tv = new TemplateValueParameter(dv.NameHash, dv.NameLocation, parent) {
Location=la.Location,
Type = dv.Type
};
LastParsedObject = tv;
if (laKind == (Colon))
{
Step();
tv.SpecializationExpression = ConditionalExpression();
}
if (laKind == (Assign))
{
Step();
tv.DefaultExpression = AssignExpression();
}
tv.EndLocation = t.EndLocation;
return tv;
}
public ulong Visit(TemplateTupleParameter templateTupleParameter)
{
return(1002149);
}
static bool CheckAndDeduceTypeTuple(TemplateTupleParameter tupleParameter,
IEnumerable<ISemantic> typeChain,
DeducedTypeDictionary deducedTypes,
ResolutionContext ctxt)
{
return new Templates.TemplateParameterDeduction(deducedTypes,ctxt).Handle(tupleParameter,typeChain);
}
