/*****
* errortest.asy
* Andy Hammerlindl 2003/08/08
*
* This struct attempts to trigger every error message reportable by the
* compiler to ensure that errors are being reported properly.
*****/
// name.cc
{
// line 33
x.y = 5;
}
{
// line 50
int x = z;
}
{
// line 67
x = 5;
}
{
// line 84 - unreachable
}
{
// line 95
x y1;
x y2();
x y3(int);
int y4(x);
struct m {
x y1;
x y2();
x y3(int);
int y4(x);
}
}
{
// line 130
int x;
x.y = 4;
}
{
// line 156
struct m {
int x,y;
}
m.u.v = 5;
}
{
// line 186
struct m {
int x,y;
}
int x = m.z;
}
{
// line 217
struct m {
int x,y;
}
m.z = 5;
}
{
// line 249 - unreachable
}
{
// line 272 - not testable without typedef
}
{
// line 283
struct m {
int x,y;
}
m.u v;
struct mm {
m.u v;
}
}
// exp.h
{
// line 109
5 = 4;
}
{
// line 136
int f, f();
f;
struct m { int f, f(); }
m.f;
}
// exp.cc
{
// line 40
int x = {};
int y = {4, 5, 6};
}
{
// line 110
int f(), f(int);
f.m = 5;
}
{
// line 122
int x;
x.m = 5;
}
{
// line 147
struct point {
int x,y;
}
point p;
int x = p.z;
}
{
// line 157
struct point {
int x, y;
}
point p;
p.z;
}
{
// line 163
struct point {
int f(), f(int);
}
point p;
p.f;
}
{
// line 204
struct point {
int x, y;
}
point p;
p.z = 5;
}
{
// line 229 - unreachable
}
{
// lines 261 and 275 - wait for subscript to be fully implemented.
}
{
// line 515
void f(int), f(int, int);
f();
f("Hello?");
}
{
// line 520 - not yet testable (need int->float casting or the like)
}
{
// line 525
void f(int);
f();
}
{
// line 649
struct point {
int x,y;
}
point p;
p = +p;
}
{
// line 1359
int x, f();
(true) ? x : f;
}
{
// line 1359
int a, a(), b, b();
(true) ? a : b;
}
{
// line 1581
int x, f();
x = f;
}
{
// line 1586
int a, a(), b, b();
a = b;
}
// newexp.cc
{
// line 34
int f() = new int () {
int x = 5;
};
}
{
// line 64
int x = new int;
}
{
// line 72
struct a {
struct b {
}
}
new a.b;
}
// stm.cc
{
// line 86
5;
}
{
// line 246
break;
}
{
// line 261
continue;
}
{
// line 282
void f() {
return 17;
}
}
{
// line 288
int f() {
return;
}
}
// dec.cc
{
// line 378
int f() {
int x = 5;
}
int g() {
if (true)
return 7;
}
}
// env.h
{
// line 99
struct m {}
struct m {}
}
{
// line 109
int f() {
return 1;
}
int f() {
return 2;
}
int x = 1;
int x = 2;
struct m {
int f() {
return 1;
}
int f() {
return 2;
}
int x = 1;
int x = 2;
}
}
// env.cc
{
// line 107 - currently unreachable as no built-ins are currently used
// in records.
}
{
// line 140
// Assuming there is a built-in function void abort(string):
void f(string);
abort = f;
}
{
// line 168 - currently unreachable as no built-in functions are
// currently used in records.
}
{
// line 222
int x = "Hello";
}
// Test permissions.
{
struct A {
private int x=4;
restricted int y=5;
private void f() {}
restricted void g() {}
}
A a;
a.x;
a.x = 4;
a.x += 5;
a.y = 6;
a.y += 7;
a.f;
a.f();
a.f = new void() {};
a.g = new void() {};
}
{
struct A {
private int x=4;
private void f() {}
}
A a;
from a unravel x;
from a unravel f;
}
{
struct A {
restricted int y=5;
restricted void g() {}
}
A a;
from a unravel y,g;
y = 6;
y += 7;
g = new void() {};
}
{
struct A {
private typedef int T;
}
A.T x;
A.T x=4;
int y=2;
A.T x=y;
A.T x=17+3*y;
}
{
struct A {
private typedef int T;
}
from A unravel T;
}
{
struct A {
private typedef int T;
}
A a;
a.T x;
a.T x=4;
int y=2;
a.T x=y;
a.T x=17+3*y;
}
{
struct A {
private typedef int T;
}
A a;
from a unravel T;
}
// Read-only settings
// Ensure that the safe and globalwrite options can't be modified inside the
// code.
{
access settings;
settings.safe=false;
settings.safe=true;
settings.globalwrite=false;
settings.globalwrite=true;
}
{
from settings access safe, globalwrite;
safe=false;
safe=true;
globalwrite=false;
globalwrite=true;
}
{
from settings access safe as x, globalwrite as y;
x=false;
x=true;
y=false;
y=true;
}
{
import settings;
settings.safe=false;
settings.safe=true;
settings.globalwrite=false;
settings.globalwrite=true;
safe=false;
safe=true;
globalwrite=false;
globalwrite=true;
}
// Test cases where var is used outside of type inference.
{
var x;
}
{
var f() { return 4; }
}
{
(var)3;
var x = (var)3;
int y = (var)3;
}
{
var[] b = new var[] { 1, 2, 3};
var[] b = new int[] { 1, 2, 3};
var[] c = {1, 2, 3};
new var[] { 4, 5, 6};
int[] d = new var[] { 4, 5, 6};
new var;
}
{
int f(var x = 3) { return 0; }
}
{
int f, f();
var g = f;
}
{
struct A { int f, f(); }
var g = A.f;
A a;
var h = a.f;
}
{
int x;
for (var i : x)
;
}
{
int x, x();
for (var i : x)
;
}
{
int x, x();
int[] x = {2,3,4};
for (var i : x)
;
}
{
int[] temp={0};
int[] v={0};
temp[v]= v;
}
// Keyword and rest errors.
{
int f(string s="" ... int[] a);
f(1,2,3 ... new int[] {4,5,6}, "hi");
f(1,2,3 ... new int[] {4,5,6} ... new int[] {7,8,9});
f(... new int[] {4,5,6}, "hi");
f(... new int[] {4,5,6} ... new int[] {7,8,9});
}
{
int f(... int[] x, int y);
int g(... int[] x, int y) { return 7; }
int f(string s ... int[] x, int y);
int g(string s ... int[] x, int y) { return 7; }
int f(int keyword x, int y);
int g(int keyword x, int y) { return 7; }
int f(int keyword x, int y, string z);
int g(int keyword x, int y, string z) { return 7; }
int f(real t, int keyword x, int y);
int g(real t, int keyword x, int y) { return 7; }
int f(real t, int keyword x, int y, string z);
int g(real t, int keyword x, int y, string z) { return 7; }
}
{
int f(int notkeyword x);
int g(int notkeyword x) { return 7; }
int f(real w, int notkeyword x);
int g(real w, int notkeyword x) { return 7; }
int f(real w, int keyword y, int notkeyword x);
int g(real w, int keyword y, int notkeyword x) { return 7; }
int f(real w, int notkeyword y, int keyword x);
int g(real w, int notkeyword y, int keyword x) { return 7; }
int f(int notkeyword x, int y, string z);
int g(int notkeyword x, int y, string z) { return 7; }
int f(int notkeyword x, int y);
int g(int notkeyword x, int y) { return 7; }
int f(int notkeyword x, int y, string z);
int g(int notkeyword x, int y, string z) { return 7; }
int f(real t, int notkeyword x, int y);
int g(real t, int notkeyword x, int y) { return 7; }
int f(real t, int notkeyword x, int y, string z);
int g(real t, int notkeyword x, int y, string z) { return 7; }
}