internal Expr ParseTypedLiteralArray()
{
var p = Mark();
TypeExpr t = null;
if (Expect(TokenType.LT))
{
t = ParseType();
if (!Expect(TokenType.GT))
{
t = null;
}
}
if (t != null && La() == TokenType.LCURLY)
{
var la = ParseLiteralArray(t);
return(la);
}
Rewind(p);
return(null);
}
public NullableType(TypeExpr underlying, Location l)
{
this.underlying = underlying;
loc = l;
eclass = ExprClass.Type;
}
FullNamedExpression ResolveMemberName(IMemberContext context, MemberName mn)
{
if (mn.Left == null)
{
return(context.LookupNamespaceOrType(mn.Name, mn.Arity, LookupMode.Probing, Location.Null));
}
var left = ResolveMemberName(context, mn.Left);
var ns = left as NamespaceExpression;
if (ns != null)
{
return(ns.LookupTypeOrNamespace(context, mn.Name, mn.Arity, LookupMode.Probing, Location.Null));
}
TypeExpr texpr = left as TypeExpr;
if (texpr != null)
{
var found = MemberCache.FindNestedType(texpr.Type, mn.Name, mn.Arity);
if (found != null)
{
return(new TypeExpression(found, Location.Null));
}
return(null);
}
return(left);
}
public override void WriteToStream(IndentStream stream)
{
stream.Write("CREATE TYPE ");
Name.WriteToStream(stream);
stream.Write(" AS ");
TypeExpr.WriteToStream(stream);
}
internal VarDecl ParseForDecl(bool implied)
{
Token n = null;
if (La() == TokenType.ID || TokenAttr.IsSoftKeyword(La()))
{
n = ConsumeAndGet();
}
Require(n, ErrorCode.Expected, "identifier");
Expr init = null;
if (Require(TokenType.ASSIGN_OP))
{
init = ParseExpression();
}
TypeExpr type = null;
if (!implied && Expect(TokenType.AS))
{
type = Require(ParseType(), ErrorCode.Expected, "type");
}
return(implied ? new ImpliedVarDecl(n, init)
: new VarDecl(n, null, type, init));
}
public override AstStatement Clone()
=> CopyValuesTo(new AstConstantDeclaration(
Pattern.Clone(),
TypeExpr?.Clone(),
Initializer.Clone(),
Documentation,
Directives?.Select(d => d.Clone()).ToList()));
public override FullNamedExpression Resolve(IResolveContext rc)
{
if (resolved != null || value == null)
{
return(resolved);
}
resolved = value.GetTypeExpression().ResolveAsTypeStep(rc, false);
if (resolved == null)
{
value = null;
return(null);
}
TypeExpr te = resolved as TypeExpr;
if (te != null)
{
if (!te.CheckAccessLevel(rc.DeclContainer))
{
Report.SymbolRelatedToPreviousError(te.Type);
Expression.ErrorIsInaccesible(resolved.Location, resolved.GetSignatureForError());
}
}
return(resolved);
}
FullNamedExpression ResolveMemberName(IMemberContext context, MemberName mn)
{
// FIXME: Default namespace lookups to C# resolution semantics (for now). Need a way to determine if PlayScript absolute
// namespace lookups should be used here.
bool absolute_ns = false;
if (mn.Left == null)
{
return(context.LookupNamespaceOrType(mn.Name, mn.Arity, LookupMode.Probing, absolute_ns, Location.Null));
}
var left = ResolveMemberName(context, mn.Left);
var ns = left as Namespace;
if (ns != null)
{
return(ns.LookupTypeOrNamespace(context, mn.Name, mn.Arity, LookupMode.Probing, Location.Null));
}
TypeExpr texpr = left as TypeExpr;
if (texpr != null)
{
var found = MemberCache.FindNestedType(texpr.Type, ParsedName.Name, ParsedName.Arity);
if (found != null)
{
return(new TypeExpression(found, Location.Null));
}
return(null);
}
return(left);
}
FullNamedExpression ResolveMemberName(IMemberContext context, MemberName mn)
{
if (mn.Left == null)
{
return(context.LookupNamespaceOrType(mn.Name, mn.Arity, Location.Null, /*ignore_cs0104=*/ false));
}
var left = ResolveMemberName(context, mn.Left);
var ns = left as Namespace;
if (ns != null)
{
return(ns.Lookup(context, mn.Name, mn.Arity, Location.Null));
}
TypeExpr texpr = left as TypeExpr;
if (texpr != null)
{
var found = MemberCache.FindNestedType(texpr.Type, ParsedName.Name, ParsedName.Arity);
if (found != null)
{
return(new TypeExpression(found, Location.Null));
}
return(null);
}
return(left);
}
public NullableType (TypeExpr underlying, Location l)
{
this.underlying = underlying;
loc = l;
eclass = ExprClass.Type;
}
private Create(TypeExpr token, GraphClass graphClass, OrientSqlExpr @from, OrientSqlExpr @to, OrientSqlExpr set)
{
_token = token;
_graphClass = graphClass;
_from = @from;
_to = to;
_set = set;
}
public void CheckAddValCtor(string valCtorName, LexLocation loc, TypeExpr ty)
{
if (_valCtorMap.TryGetValue(valCtorName, out var other))
{
throw new ValueCtorDuplicatedException(other._lexLocation, loc);
}
_valCtorMap.Add(valCtorName, ty);
}
/// <summary>
/// TypeExpr
/// (ANY_TYPE | ID (DOT ID)*) (LBRACKET ConditionalExpr? RBRACKET)?
/// </summary>
/// <returns></returns>
private TypeExpr ParseTypeExpr(bool expectArraySize = false)
{
TypeExpr ret = new TypeExpr();
Token t = Consume();
switch (t.Type)
{
case TokenType.BOOL:
ret.Type = SyntacticValueType.BOOL;
break;
case TokenType.INT:
ret.Type = SyntacticValueType.INT;
break;
case TokenType.DOUBLE:
ret.Type = SyntacticValueType.DOUBLE;
break;
case TokenType.VOID:
ret.Type = SyntacticValueType.VOID;
break;
case TokenType.STRING:
ret.Type = SyntacticValueType.STRING;
break;
case TokenType.ID:
ret.Type = SyntacticValueType.CLASS;
ret.ClassName = new List <string>()
{
t.Literal
};
while (Check(TokenType.DOT))
{
Consume(TokenType.DOT);
t = Consume(TokenType.ID);
ret.ClassName.Add(t.Literal);
}
break;
default:
throw new SyntaxError("Unknown type", t);
}
if (Check(TokenType.LBRACKET))
{
t = Consume(TokenType.LBRACKET);
ret.Expr1 = Expr.MakeOp(OpType.ARRAY_ACCESS, null, t.Line);
if (expectArraySize)
{
ret.Expr1.Expr1 = ParseCondtionalExpr();
}
Consume(TokenType.RBRACKET);
}
return(ret);
}
public Enum(TypeContainer parent, TypeExpression type, Modifiers mod_flags, MemberName name, Attributes attrs)
: base(parent, name, attrs, MemberKind.Enum)
{
underlying_type_expr = type;
var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE;
ModFlags = ModifiersExtensions.Check(AllowedModifiers, mod_flags, accmods, Location, Report);
spec = new EnumSpec(null, this, null, null, ModFlags);
}
internal TypeExpr ParseTypeSuffix(TypeExpr t)
{
if (t != null)
{
// TODO nvk: parse PTR, array specifiers
}
return(t);
}
internal TryStmt ParseTryStmt()
{
Token t = RequireAndGet(TokenType.TRY);
Require(TokenType.EOS);
var s = ParseStatementBlock();
var cb = new List <CatchBlock>();
while (La() == TokenType.CATCH)
{
cb.Add(ParseCatchBlock());
}
FinallyBlock fb = null;
if (La() == TokenType.FINALLY)
{
var ft = ConsumeAndGet();
Require(TokenType.EOS);
fb = new FinallyBlock(ft, ParseStatementBlock());
}
Require(TokenType.END);
Expect(TokenType.TRY);
Require(TokenType.EOS);
return(new TryStmt(t, s, cb.ToArray(), fb));
CatchBlock ParseCatchBlock()
{
Token ct = RequireAndGet(TokenType.CATCH);
Expect(TokenType.TO);
Token n = ParseVarIdName();
TypeExpr type = null;
if (Expect(TokenType.AS))
{
Require(type = ParseType(), ErrorCode.Expected, "type");
}
Expr when = null;
if (Expect(TokenType.WHEN))
{
when = RequireExpression();
}
Expect(TokenType.EOS);
var cs = ParseStatementBlock();
return(new CatchBlock(ct, n, type, when, cs));
}
}
public Enum(NamespaceEntry ns, DeclSpace parent, TypeExpr type,
int mod_flags, MemberName name, Attributes attrs)
: base(ns, parent, name, attrs, Kind.Enum)
{
this.base_type = type;
int accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE;
ModFlags = Modifiers.Check(AllowedModifiers, mod_flags, accmods, Location);
}
internal Expr ParseLiteralArray(TypeExpr t = null)
{
Require(Expect(TokenType.LCURLY), ErrorCode.Expected, "{");
var e = ParseExprList(true);
Require(Expect(TokenType.RCURLY) || AllowMissingSyntax, ErrorCode.Expected, "}");
return(new LiteralArray(e, t));
}
protected void EmitCall(EmitContext ec, Expression binder, Arguments arguments, bool isStatement)
{
int dyn_args_count = arguments == null ? 0 : arguments.Count;
TypeExpr site_type = CreateSiteType(ec, arguments, dyn_args_count, isStatement);
var field = CreateSiteField(ec, site_type);
if (field == null)
{
return;
}
FieldExpr site_field_expr = new FieldExpr(field, loc);
SymbolWriter.OpenCompilerGeneratedBlock(ec);
Arguments args = new Arguments(1);
args.Add(new Argument(binder));
StatementExpression s = new StatementExpression(new SimpleAssign(site_field_expr, new Invocation(new MemberAccess(site_type, "Create"), args)));
BlockContext bc = new BlockContext(ec.MemberContext, null, TypeManager.void_type);
if (s.Resolve(bc))
{
Statement init = new If(new Binary(Binary.Operator.Equality, site_field_expr, new NullLiteral(loc), loc), s, loc);
init.Emit(ec);
}
args = new Arguments(1 + dyn_args_count);
args.Add(new Argument(site_field_expr));
if (arguments != null)
{
foreach (Argument a in arguments)
{
if (a is NamedArgument)
{
// Name is not valid in this context
args.Add(new Argument(a.Expr, a.ArgType));
continue;
}
args.Add(a);
}
}
Expression target = new DelegateInvocation(new MemberAccess(site_field_expr, "Target", loc).Resolve(bc), args, loc).Resolve(bc);
if (target != null)
{
target.Emit(ec);
}
SymbolWriter.CloseCompilerGeneratedBlock(ec);
}
TypeExpr LookupType(string name, Location loc)
{
if (cached_types.Contains(name))
{
return(cached_types [name] as TypeExpr);
}
Type t = null;
if (declspaces != null)
{
DeclSpace tdecl = declspaces [name] as DeclSpace;
if (tdecl != null)
{
//
// Note that this is not:
//
// t = tdecl.DefineType ()
//
// This is to make it somewhat more useful when a DefineType
// fails due to problems in nested types (more useful in the sense
// of fewer misleading error messages)
//
tdecl.DefineType();
t = tdecl.TypeBuilder;
if (RootContext.EvalMode)
{
// Replace the TypeBuilder with a System.Type, as
// Reflection.Emit fails otherwise (we end up pretty
// much with Random type definitions later on).
Type tt = t.Assembly.GetType(t.Name);
if (tt != null)
{
t = tt;
}
}
}
}
string lookup = t != null ? t.FullName : (fullname.Length == 0 ? name : fullname + "." + name);
Type rt = root.LookupTypeReflection(lookup, loc);
// HACK: loc.IsNull when the type is core type
if (t == null || (rt != null && loc.IsNull))
{
t = rt;
}
TypeExpr te = t == null ? null : new TypeExpression(t, Location.Null);
cached_types [name] = te;
return(te);
}
public void AddDefiningValCtor(SimpleName valCtorName, TypeExpr final)
{
var loc = valCtorName._lexLocation;
var name = valCtorName.ToString();
if (ValueCtorMap.TryGetValue(name, out var ty))
{
throw new ValueCtorDuplicatedException(ty._lexLocation, loc);
}
_definingCtor.CheckAddValCtor(name, loc, final);
CheckValCtorType(valCtorName, final);
}
/// <summary>
/// Params
/// TypeExpr Id (COMMA Params)?
/// </summary>
/// <returns></returns>
private VarStmt ParseParams()
{
TypeExpr type = ParseTypeExpr();
IdExpr id = ParseId();
VarStmt vars = new VarStmt(AccessFlag.DefaultFlag, type, id.Id, null);
if (Check(TokenType.COMMA))
{
Consume(TokenType.COMMA);
vars.SiblingAST = ParseParams();
}
return(vars);
}
internal VarDecl ParseXBaseVarDecl(bool local = false, bool parseArraySub = false, bool parseInit = false, bool parseType = false)
{
// Parse variable name
Token n = RequireVarIdName();
// Parse array sub indices
List <Expr> asub = null;
if (parseArraySub && Expect(TokenType.LBRKT))
{
asub = new List <Expr>();
do
{
asub.Add(RequireExpression());
if (Expect(TokenType.COMMA))
{
continue;
}
if (La() == TokenType.RBRKT && La(2) == TokenType.LBRKT)
{
Consume(2);
continue;
}
break;
} while (true);
Require(Expect(TokenType.RBRKT), ErrorCode.Expected, TokenType.RBRKT);
}
// Parse initializer
Expr init = null;
if (parseInit && Expect(TokenType.ASSIGN_OP))
{
init = ParseExpression();
}
// Parse type
TypeExpr type = null;
if (parseType && Expect(TokenType.AS)) // type parsed but ignored
{
Require(ParseType(), ErrorCode.Expected, "type");
if (Expect(TokenType.OF))
{
Require(ParseId(), ErrorCode.Expected, "identifier");
}
}
return(local ? new VarDecl(n, asub?.ToArray(), type, init)
: new MemVarDecl(n, asub?.ToArray(), type, init));
}
// <summary>
// Resolve is used in method definitions
// </summary>
public virtual Type Resolve(IResolveContext ec)
{
// HACK: to resolve attributes correctly
this.resolve_context = ec;
if (parameter_type != null)
{
return(parameter_type);
}
TypeExpr texpr = TypeName.ResolveAsTypeTerminal(ec, false);
if (texpr == null)
{
return(null);
}
parameter_type = texpr.Type;
if ((modFlags & Parameter.Modifier.ISBYREF) != 0 &&
TypeManager.IsSpecialType(parameter_type))
{
Report.Error(1601, Location, "Method or delegate parameter cannot be of type `{0}'",
GetSignatureForError());
return(null);
}
#if GMCS_SOURCE
TypeParameterExpr tparam = texpr as TypeParameterExpr;
if (tparam != null)
{
return(parameter_type);
}
#endif
if ((parameter_type.Attributes & Class.StaticClassAttribute) == Class.StaticClassAttribute)
{
Report.Error(721, Location, "`{0}': static types cannot be used as parameters",
texpr.GetSignatureForError());
return(parameter_type);
}
if ((modFlags & Modifier.This) != 0 && parameter_type.IsPointer)
{
Report.Error(1103, Location, "The type of extension method cannot be `{0}'",
TypeManager.CSharpName(parameter_type));
}
return(parameter_type);
}
//
// System.Linq.Expressions.ParameterExpression type
//
public static TypeExpr ResolveParameterExpressionType(IMemberContext ec, Location location)
{
if (parameter_expr_tree_type != null)
{
return(parameter_expr_tree_type);
}
TypeSpec p_type = ec.Module.PredefinedTypes.ParameterExpression.Resolve(location);
parameter_expr_tree_type = new TypeExpression(p_type, location).
ResolveAsTypeTerminal(ec, false);
return(parameter_expr_tree_type);
}
static partial void PrintExt(TypeExpr p, int _i_)
{
if (p is UType)
{
if (_i_ > 2)
{
Render(LEFT_PARENTHESIS);
}
Render("TYPE");
if (_i_ > 2)
{
Render(RIGHT_PARENTHESIS);
}
}
}
protected override TypeExpr [] ResolveBaseTypes(out TypeExpr base_class)
{
var mtype = Iterator.OriginalIteratorType;
if (Mutator != null)
{
mtype = Mutator.Mutate(mtype);
}
iterator_type_expr = new TypeExpression(mtype, Location);
generic_args = new TypeArguments(iterator_type_expr);
var list = new List <FullNamedExpression> ();
if (Iterator.IsEnumerable)
{
enumerable_type = new TypeExpression(
TypeManager.ienumerable_type, Location);
list.Add(enumerable_type);
if (TypeManager.generic_ienumerable_type != null)
{
generic_enumerable_type = new GenericTypeExpr(
TypeManager.generic_ienumerable_type,
generic_args, Location);
list.Add(generic_enumerable_type);
}
}
enumerator_type = new TypeExpression(
TypeManager.ienumerator_type, Location);
list.Add(enumerator_type);
list.Add(new TypeExpression(TypeManager.idisposable_type, Location));
var ienumerator_generic = Module.PredefinedTypes.IEnumeratorGeneric;
if (ienumerator_generic.Define())
{
generic_enumerator_type = new GenericTypeExpr(ienumerator_generic.TypeSpec, generic_args, Location);
list.Add(generic_enumerator_type);
}
type_bases = list;
return(base.ResolveBaseTypes(out base_class));
}
private TypeCtorSig(ParsingContext ctx, string name, string[] pList, LexLocation lexLocation)
{
Name = name;
ParamList = pList;
Loc = lexLocation;
_definingTypeAsTyExpr = TyQName.Create(Name, Loc, ctx);
if (ParamList.Length > 0)
{
ListTypeExpr pLst = new ListTypeExpr();
foreach (var pNm in ParamList)
{
//TODO improve location of parameter
pLst.AddLast(TyQName.Create(pNm, Loc, ctx));
}
_definingTypeAsTyExpr = new TyApp(_definingTypeAsTyExpr, pLst, Loc, ctx);
}
}
/// <summary>
/// 这里用了LookAhead
/// 此外不允许不带定义的声明
/// DeclarationStmt
/// ACCESS_FLAG* TypeExpr FuncDeclarator BlockStmt
/// ACCESS_FLAG* TypeExpr VarDeclarator SEMICOLON
/// </summary>
/// <returns></returns>
private DeclarationStmt ParseDeclOrDefStmt()
{
AccessFlag flag = ParserAccessFlag();
TypeExpr type = ParseTypeExpr();
if (Check(TokenType.LPAREN) || CheckAt(1, TokenType.LPAREN))
{
FuncStmt ret = ParseFuncDeclarator(type, flag);
ret.Body = ParseBlockStmt();
return(ret);
}
else
{
VarStmt ret = ParseVarDeclarator(type, flag);
Consume(TokenType.SEMICOLON);
return(ret);
}
}
internal VarDecl ParseFoxDimVarDecl()
{
// Parse variable name
Token n = RequireIdName();
// Parse array sub indices
List <Expr> asub = null;
if (ExpectAndGetAny(TokenType.LBRKT, TokenType.LPAREN) is Token lp)
{
asub = new List <Expr>();
do
{
asub.Add(RequireExpression());
if (Expect(TokenType.COMMA))
{
continue;
}
if (La() == TokenType.RBRKT && La(2) == TokenType.LBRKT)
{
Consume(2);
continue;
}
break;
} while (true);
var rp = Expect(lp.Type == TokenType.LBRKT ? TokenType.RBRKT : TokenType.RPAREN);
Require(rp, ErrorCode.Expected, rp);
}
// Parse type
TypeExpr type = null;
if (Expect(TokenType.AS)) // type parsed byt ignored
{
Require(ParseType(), ErrorCode.Expected, "type");
if (Expect(TokenType.OF))
{
Require(ParseId(), ErrorCode.Expected, "identifier");
}
}
return(new VarDecl(n, asub?.ToArray(), type, null));
}
private void CheckTypeCtorKind(TypeCtorSig sig)
{
//TODO _definingCtor.Name != Int , Double, String
TypeExpr ctorKind = UType.Instance;
for (var i = 0; i < _definingCtor.ParamList.Length; i++)
{
if (_definingCtorEnv.ContainsKey(_definingCtor.ParamList[i]))
{
throw new SemanticException($"duplicated parameter names of Type Constructor:{_definingCtor.ParamList[i]}", _definingCtor.Loc);
}
_definingCtorEnv.Add(_definingCtor.ParamList[i], UType.Instance);
ctorKind = TyArr.Create(UType.Instance, ctorKind, this);
}
_definingCtorEnv.Add(_definingCtor.Name, ctorKind);
_definingCtor.Kind = ctorKind;
}
public AnonymousMethodMethod (TypeDefinition parent, AnonymousExpression am, AnonymousMethodStorey storey,
TypeExpr return_type,
Modifiers mod, MemberName name,
ParametersCompiled parameters)
: base (parent, return_type, mod | Modifiers.COMPILER_GENERATED,
name, parameters, null)
{
this.AnonymousMethod = am;
this.Storey = storey;
Parent.PartialContainer.Members.Add (this);
Block = new ToplevelBlock (am.block, parameters);
}
public override Null Visit(TypeExpr node)
{
context = null;
node.computedType = new MetaType { instanceType = node.type };
return null;
}
