public override void VisitGenericTypeRef(GenericTypeRef x) { VisitElement(x.TargetType); var t = _results.Pop(); if (t.HasValue && !t.Value.IsGeneric) { bool resolved = true; var generics = new GenericQualifiedName[x.GenericParams.Count]; for (int i = 0; i < generics.Length; i++) { VisitElement(x.GenericParams[i]); var g = _results.Pop(); if (g.HasValue) { generics[i] = g.Value; } else { resolved = false; } } if (resolved) { _results.Push(new GenericQualifiedName(t.Value.QualifiedName, generics)); return; } } // _results.Push(null); }
public IndirectStMtdCall(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, Expression /*!*/ nameExpr, CallSignature signature) : base(span, className, classNamePosition, signature) { _methodNameExpr = nameExpr; }
public IndirectStMtdCall(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, CompoundVarUse /*!*/ mtdNameVar, IList <ActualParam> parameters, IList <TypeRef> genericParams) : base(span, className, classNamePosition, parameters, genericParams) { this.methodNameVar = mtdNameVar; }
public DirectStMtdCall( Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, Name methodName, Text.Span methodNamePosition, CallSignature signature) : base(span, className, classNamePosition, signature) { this.methodName = new NameRef(methodNamePosition, methodName); }
public CatchItem(Position p, GenericQualifiedName className, DirectVarUse /*!*/ variable, List <Statement> /*!*/ statements) : base(p) { Debug.Assert(variable != null && statements != null); this.className = className; this.variable = variable; this.statements = statements; }
private void fatalError(FlowController flow, bool removeFlowChildren) { var catchedType = new GenericQualifiedName(new QualifiedName(new Name(string.Empty))); var catchVariable = new VariableIdentifier(string.Empty); var description = new CatchBlockDescription(flow.ProgramEnd, catchedType, catchVariable); var info = new ThrowInfo(description, new MemoryEntry()); var throws = new ThrowInfo[] { info }; flow.SetThrowBranching(throws, removeFlowChildren); }
private void CheckReservedNamesAbsence(GenericQualifiedName genericName, Position position) { if (genericName.QualifiedName.IsReservedClassName) { errors.Add(Errors.CannotUseReservedName, SourceUnit, position, genericName.QualifiedName.Name); } if (genericName.GenericParams != null) { CheckReservedNamesAbsence(genericName.GenericParams, position); } }
/// <summary> /// Creates new instance of CatchBlockDescription /// </summary> /// <param name="targetPoint">Point where to jump</param> /// <param name="catchedType">Type of Exception</param> /// <param name="catchVariable">Name of catched variables</param> public CatchBlockDescription(ProgramPointBase targetPoint, GenericQualifiedName catchedType, VariableIdentifier catchVariable) { TargetPoint = targetPoint; CatchedType = catchedType; if (CatchedType.QualifiedName.Name.Value == null) { CatchedType = new GenericQualifiedName(new QualifiedName(new Name("$noname"))); } CatchVariable = catchVariable; }
internal static TypeRef FromGenericQualifiedName(Span span, GenericQualifiedName qname) { var tref = new ClassTypeRef(span, qname.QualifiedName); if (qname.IsGeneric) { return(new GenericTypeRef(span, tref, qname.GenericParams.Select(p => FromObject(Span.Invalid, p)).ToList())); } else { return(tref); } }
private TryStmt /*!*/ CreateTryStmt(Position pos, List <Statement> /*!*/ tryStmts, Position classNamePos, GenericQualifiedName /*!*/ className, Position variablePos, string /*!*/ variable, List <Statement> /*!*/ catchStmts, List <CatchItem> catches) { CatchItem catch_item = new CatchItem(classNamePos, className, new DirectVarUse(variablePos, new VariableName(variable)), catchStmts); if (catches != null) { catches.Insert(0, catch_item); } else { catches = new List <CatchItem>(); catches.Add(catch_item); } return(new TryStmt(pos, tryStmts, catches)); }
internal ClassConstant TryResolveClassConstantGlobally(GenericQualifiedName typeName, VariableName constantName) { if (typeName.GenericParams.Length != 0) { return(null); } QualifiedName?alias; DType type = ResolveTypeName(typeName.QualifiedName, Scope.Global, out alias, null, Position.Invalid, false); ClassConstant constant; if (type != null && type.IsDefinite && type.GetConstant(constantName, null, out constant) == GetMemberResult.OK) { return(constant); } else { return(null); } }
internal static DirectTypeRef /*!*/ FromGenericQualifiedName(Text.Span span, GenericQualifiedName genericQualifiedName) { List <TypeRef> genericParams; if (genericQualifiedName.IsGeneric) { genericParams = new List <TypeRef>(genericQualifiedName.GenericParams.Length); foreach (var obj in genericQualifiedName.GenericParams) { TypeRef objtype; if (obj is GenericQualifiedName) { objtype = FromGenericQualifiedName(Text.Span.Invalid, (GenericQualifiedName)obj); } else if (obj is PrimitiveTypeName) { objtype = new PrimitiveTypeRef(Text.Span.Invalid, (PrimitiveTypeName)obj); } else { objtype = new PrimitiveTypeRef(Text.Span.Invalid, new PrimitiveTypeName(QualifiedName.Object)); } genericParams.Add(objtype); } } else { //if (genericQualifiedName.QualifiedName.IsPrimitiveTypeName) // return new PrimitiveTypeRef(position, new PrimitiveTypeName(genericQualifiedName.QualifiedName)); genericParams = TypeRef.EmptyList; } return(new DirectTypeRef(span, genericQualifiedName.QualifiedName, genericParams.ToList())); }
internal static DirectTypeRef/*!*/FromGenericQualifiedName(Text.Span span, GenericQualifiedName genericQualifiedName) { List<TypeRef> genericParams; if (genericQualifiedName.IsGeneric) { genericParams = new List<TypeRef>(genericQualifiedName.GenericParams.Length); foreach (var obj in genericQualifiedName.GenericParams) { TypeRef objtype; if (obj is GenericQualifiedName) objtype = FromGenericQualifiedName(Text.Span.Invalid, (GenericQualifiedName)obj); else if (obj is PrimitiveTypeName) objtype = new PrimitiveTypeRef(Text.Span.Invalid, (PrimitiveTypeName)obj); else objtype = new PrimitiveTypeRef(Text.Span.Invalid, new PrimitiveTypeName(QualifiedName.Object)); genericParams.Add(objtype); } } else { //if (genericQualifiedName.QualifiedName.IsPrimitiveTypeName) // return new PrimitiveTypeRef(position, new PrimitiveTypeName(genericQualifiedName.QualifiedName)); genericParams = TypeRef.EmptyList; } return new DirectTypeRef(span, genericQualifiedName.QualifiedName, genericParams.ToList()); }
public IndirectStFldUse(Position position, GenericQualifiedName typeName, Expression/*!*/ fieldNameExpr) : base(position, typeName) { this.fieldNameExpr = fieldNameExpr; }
internal static DirectTypeRef/*!*/FromGenericQualifiedName(Position position, GenericQualifiedName genericQualifiedName) { var genericParams = genericQualifiedName.GenericParams.Select<object, TypeRef>(obj => { if (obj is PrimitiveType) return new PrimitiveTypeRef(Position.Invalid, (PrimitiveType)obj); if (obj is GenericQualifiedName) return FromGenericQualifiedName(Position.Invalid, (GenericQualifiedName)obj); return new PrimitiveTypeRef(Position.Invalid, PrimitiveType.Object); }); return new DirectTypeRef(position, genericQualifiedName.QualifiedName, genericParams.ToList()); }
public StaticFieldUse(Position position, GenericQualifiedName typeName) : base(position) { this.typeName = typeName; }
public DType/*!*/ ResolveTypeName(GenericQualifiedName genericName, PhpType referringType, PhpRoutine referringRoutine, Position position, bool mustResolve) { DType type = ResolveTypeName(genericName.QualifiedName, referringType, referringRoutine, position, mustResolve); DTypeDesc[] arguments = (genericName.GenericParams.Length > 0) ? new DTypeDesc[genericName.GenericParams.Length] : DTypeDesc.EmptyArray; for (int i = 0; i < arguments.Length; i++) { arguments[i] = ResolveType(genericName.GenericParams[i], referringType, referringRoutine, position, mustResolve).TypeDesc; } return type.MakeConstructedType(this, arguments, position); }
public DirectStFldUse(Position position, GenericQualifiedName qualifiedName, Position qualifiedNamePosition, VariableName propertyName, Position propertyNamePosition) : this(position, DirectTypeRef.FromGenericQualifiedName(qualifiedNamePosition, qualifiedName), propertyName, propertyNamePosition) { }
/// <summary> /// Resolve value, determined by given static field specifier on given type /// </summary> /// <param name="type">Type which static field is resolved</param> /// <param name="field">Possible fields</param> /// <returns>Snapshot entry for static field</returns> public abstract ReadWriteSnapshotEntryBase ResolveStaticField(GenericQualifiedName type, MemoryEntry field);
public StaticFieldUse(Text.Span span, Text.Span nameSpan, GenericQualifiedName typeName, Text.Span typeNamePosition) : this(span, nameSpan, DirectTypeRef.FromGenericQualifiedName(typeNamePosition, typeName)) { }
public DirectStFldUse(Text.Span span, GenericQualifiedName qualifiedName, Text.Span qualifiedNameSpan, VariableName propertyName, Text.Span propertyNameSpan) : this(span, DirectTypeRef.FromGenericQualifiedName(qualifiedNameSpan, qualifiedName), propertyName, propertyNameSpan) { }
public DirectStFldUse(Position position, GenericQualifiedName qualifiedName, Position qualifiedNamePosition, VariableName propertyName, Position propertyNamePosition) : this(position, DirectTypeRef.FromGenericQualifiedName(qualifiedNamePosition, qualifiedName), propertyName, propertyNamePosition) { }
internal override void Analyze(Analyzer/*!*/ analyzer) { // method redeclared: if (method == null) return; base.Analyze(analyzer); PhpType declaring_type = analyzer.CurrentType; analyzer.EnterMethodDeclaration(method); typeSignature.Analyze(analyzer); signature.Analyze(analyzer); method.Validate(analyzer.ErrorSink); // note, if the declaring type's base is unknown then it cannot be a CLR type; ClrType base_clr_type = method.DeclaringType.Base as ClrType; if (baseCtorParams != null) { if (base_clr_type != null) { AnalyzeBaseCtorCallParams(analyzer, base_clr_type); } else if (!method.IsConstructor || method.DeclaringType.Base == null || body == null) { analyzer.ErrorSink.Add(Errors.UnexpectedParentCtorInvocation, analyzer.SourceUnit, position); baseCtorParams = null; } else if (method.DeclaringType.Base.Constructor == null) { // base class has no constructor, the default parameterless is silently called (and that does nothing); // report error, if there are any parameters passed to the parameterless ctor: if (baseCtorParams.Count > 0) analyzer.ErrorSink.Add(Errors.UnexpectedParentCtorInvocation, analyzer.SourceUnit, position); baseCtorParams = null; } else { GenericQualifiedName parent_name = new GenericQualifiedName(new QualifiedName(Name.ParentClassName)); DirectStMtdCall call_expr = new DirectStMtdCall( position, parent_name, Position.Invalid, method.DeclaringType.Base.Constructor.Name, Position.Invalid, baseCtorParams, TypeRef.EmptyList); body.Insert(0, new ExpressionStmt(position, call_expr)); baseCtorParams = null; } } else { // the type immediately extends CLR type with no default ctor, yet there is no call to the base ctor; // note, all constructor overloads reflected from the CLR type are visible as we are in a subclass: if (method.IsConstructor && base_clr_type != null && !base_clr_type.ClrConstructor.HasParameterlessOverload) { analyzer.ErrorSink.Add(Errors.ExpectingParentCtorInvocation, analyzer.SourceUnit, position); } } if(method.IsDllImport && !method.IsStatic) analyzer.ErrorSink.Add(Errors.DllImportMethodMustBeStatic, analyzer.SourceUnit, position); if(method.IsDllImport && method.IsAbstract) analyzer.ErrorSink.Add(Errors.DllImportMethodCannotBeAbstract, analyzer.SourceUnit, position); if (body != null) body.Analyze(analyzer); method.ValidateBody(analyzer.ErrorSink); analyzer.LeaveMethodDeclaration(); // add entry point if applicable: analyzer.SetEntryPoint(method, position); }
public StaticFieldUse(Position position, Position namePosition, GenericQualifiedName typeName, Position typeNamePosition) : this(position, namePosition, DirectTypeRef.FromGenericQualifiedName(typeNamePosition, typeName)) { }
internal DirectStFldUse(Text.Span span, GenericQualifiedName qualifiedName, Span qualifiedNameSpan, VariableName propertyName, Span propertyNameSpan) : this(span, TypeRef.FromGenericQualifiedName(qualifiedNameSpan, qualifiedName), propertyName, propertyNameSpan) { }
internal StaticFieldUse(Span span, GenericQualifiedName typeName, Span typeNamePosition) : this(span, TypeRef.FromGenericQualifiedName(typeNamePosition, typeName)) { }
public DirectStMtdCall(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, Name methodName, Text.Span methodNamePosition, List<ActualParam>/*!*/ parameters, List<TypeRef>/*!*/ genericParams) : base(span, methodNamePosition, className, classNamePosition, parameters, genericParams) { this.methodName = methodName; }
public TypeDecl(SourceUnit/*!*/ sourceUnit, Position position, Position entireDeclarationPosition, ShortPosition headingEndPosition, ShortPosition declarationBodyPosition, bool isConditional, Scope scope, PhpMemberAttributes memberAttributes, bool isPartial, Name className, NamespaceDecl ns, List<FormalTypeParam>/*!*/ genericParams, GenericQualifiedName? baseClassName, List<GenericQualifiedName>/*!*/ implementsList, List<TypeMemberDecl>/*!*/ members, List<CustomAttribute> attributes) : base(position) { Debug.Assert(genericParams != null && implementsList != null && members != null); this.name = className; this.ns = ns; this.typeSignature = new TypeSignature(genericParams); this.baseClassName = baseClassName; this.implementsList = implementsList; this.members = members; this.attributes = new CustomAttributes(attributes); this.entireDeclarationPosition = entireDeclarationPosition; this.headingEndPosition = headingEndPosition; this.declarationBodyPosition = declarationBodyPosition; this.partialKeyword = isPartial; // remember current aliases: var aliases = (ns != null) ? ns.Aliases : sourceUnit.Aliases; if (aliases.Count > 0) validAliases = new Dictionary<string, QualifiedName>(aliases); // create stuff necessary for inclusion resolving process, other structures are created duirng analysis: QualifiedName qn = (ns != null) ? new QualifiedName(name, ns.QualifiedName) : new QualifiedName(name); type = new PhpType(qn, memberAttributes, isPartial, typeSignature, isConditional, scope, sourceUnit, position); //// add alias for private classes (if not added yet by partial declaration): //if (type.IsPrivate) // sourceUnit.AddTypeAlias(qn, this.name); // member-analysis needs the node: type.Declaration.Node = this; }
public ClassConstUse(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, string /*!*/ name, Text.Span namePosition) : this(span, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), name, namePosition) { }
public CatchItem(Text.Span p, GenericQualifiedName className, DirectVarUse/*!*/ variable, List<Statement>/*!*/ statements) : base(p) { Debug.Assert(variable != null && statements != null); this.className = className; this.variable = variable; this.statements = statements; }
public StaticFieldUse(Text.Span span, Text.Span nameSpan, GenericQualifiedName typeName, Text.Span typeNamePosition) : this(span, nameSpan, DirectTypeRef.FromGenericQualifiedName(typeNamePosition, typeName)) { }
/// <summary> /// Static method call. /// </summary> /// <param name="span">Entire element span.</param> /// <param name="className">Name of the containing class.</param> /// <param name="classNamePosition">Class name position.</param> /// <param name="parameters">Actual parameters.</param> /// <param name="genericParams">Generic parameters.</param> internal StaticMtdCall(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, IList <ActualParam> parameters, IList <TypeRef> genericParams) : this(span, TypeRef.FromGenericQualifiedName(classNamePosition, className), parameters, genericParams) { }
public ClassConstUse(Position position, GenericQualifiedName className, Position classNamePosition, string /*!*/ name, Position namePosition) : this(position, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), name, namePosition) { }
public DirectStMtdCall(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, Name methodName, Text.Span methodNamePosition, IList <ActualParam> parameters, IList <TypeRef> genericParams) : base(span, className, classNamePosition, parameters, genericParams) { this.methodName = new NameRef(methodNamePosition, methodName); }
/// <summary> /// Create new Instance Of CatchBasicBlock /// </summary> /// <param name="variable">Variable name of catch Exception</param> /// <param name="className">Class of catch Exception</param> public CatchBasicBlock(DirectVarUse /*!*/ variable, GenericQualifiedName className) : base() { Variable = variable; ClassName = className; }
public DirectStMtdCall(Position position, GenericQualifiedName className, Name methodName, List<ActualParam>/*!*/ parameters, List<TypeRef>/*!*/ genericParams) : base(position, className, parameters, genericParams) { this.methodName = methodName; }
private VariableUse CreateStaticFieldUse(Position position, GenericQualifiedName /*!*/ className, Position classNamePosition, CompoundVarUse /*!*/ field) { return(CreateStaticFieldUse(position, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), field)); }
public StaticMtdCall(Position position, GenericQualifiedName className, List<ActualParam>/*!*/ parameters, List<TypeRef>/*!*/ genericParams) : this(position, DirectTypeRef.FromGenericQualifiedName(position, className), parameters, genericParams) { }
public DirectStFldUse(Position position, GenericQualifiedName typeName, VariableName propertyName) : base(position, typeName) { this.propertyName = propertyName; }
public override ReadWriteSnapshotEntryBase ResolveStaticField(GenericQualifiedName type, MemoryEntry field) { throw new NotImplementedException(); }
public IndirectStMtdCall(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, CompoundVarUse/*!*/ mtdNameVar, IList<ActualParam> parameters, IList<TypeRef> genericParams) : base(span, mtdNameVar.Span, className, classNamePosition, parameters, genericParams) { this.methodNameVar = mtdNameVar; }
public DirectStFldUse(Position position, GenericQualifiedName qualifiedName, VariableName propertyName) : base(position, DirectTypeRef.FromGenericQualifiedName(position, qualifiedName)) { }
public StaticMtdCall(Text.Span span, Text.Span methodNamePosition, GenericQualifiedName className, Text.Span classNamePosition, List<ActualParam>/*!*/ parameters, List<TypeRef>/*!*/ genericParams) : this(span, methodNamePosition, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), parameters, genericParams) { }
public PseudoClassConstUse(Position position, GenericQualifiedName className, Position classNamePosition, Types type, Position namePosition) : this(position, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), type, namePosition) { }
public StaticMtdCall(Position position, GenericQualifiedName className, List<ActualParam>/*!*/ parameters, List<TypeRef>/*!*/ genericParams) : base(position, parameters, genericParams) { this.className = className; }
public TypeHintValue(GenericQualifiedName hint) : this((object)hint) { }
public ClassConstUse(Position position, GenericQualifiedName className, Position classNamePosition, string/*!*/ name, Position namePosition) : this(position, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), name, namePosition) { }
/// <summary> /// Resolve value, determined by given static field specifier on given type /// </summary> /// <param name="type">Type which static field is resolved</param> /// <param name="field">Specifier of resolved field</param> /// <returns>Snapshot entry for static field</returns> public abstract ReadWriteSnapshotEntryBase ResolveStaticField(GenericQualifiedName type, VariableIdentifier field);
public StaticFieldUse(Position position, Position namePosition, GenericQualifiedName typeName, Position typeNamePosition) : this(position, namePosition, DirectTypeRef.FromGenericQualifiedName(typeNamePosition, typeName)) { }
internal static DirectTypeRef /*!*/ FromGenericQualifiedName(Position position, GenericQualifiedName genericQualifiedName) { var genericParams = genericQualifiedName.GenericParams.Select <object, TypeRef>(obj => { if (obj is PrimitiveType) { return(new PrimitiveTypeRef(Position.Invalid, (PrimitiveType)obj)); } if (obj is GenericQualifiedName) { return(FromGenericQualifiedName(Position.Invalid, (GenericQualifiedName)obj)); } return(new PrimitiveTypeRef(Position.Invalid, PrimitiveType.Object)); }); return(new DirectTypeRef(position, genericQualifiedName.QualifiedName, genericParams.ToList())); }
public IndirectStMtdCall(Position position, GenericQualifiedName className, CompoundVarUse/*!*/ mtdNameVar, List<ActualParam>/*!*/ parameters, List<TypeRef>/*!*/ genericParams) : base(position, className, parameters, genericParams) { this.methodNameVar = mtdNameVar; }
public PseudoClassConstUse(Position position, GenericQualifiedName className, Position classNamePosition, Types type, Position namePosition) : this(position, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), type, namePosition) { }
public ClassConstUse(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, string/*!*/ name, Text.Span namePosition) : this(span, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), name, namePosition) { }
public PseudoClassConstUse(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, Types type, Text.Span namePosition) : this(span, DirectTypeRef.FromGenericQualifiedName(classNamePosition, className), type, namePosition) { }
internal PseudoClassConstUse(Text.Span span, GenericQualifiedName className, Text.Span classNamePosition, Types type, Text.Span namePosition) : this(span, ClassTypeRef.FromGenericQualifiedName(classNamePosition, className), type, namePosition) { }
public ClassConstUse(Position position, GenericQualifiedName className, string/*!*/ name) : base(position) { this.className = className; this.name = new VariableName(name); }