Shader error in '...': Unknown parameter type (39) for '...' at kernel '...'

I know I'm just dumping a lot of code here, but this error message that I am getting does not give a real line number nor does it show up on Google for me. I don't even know what it is supposed to mean, since F3 and G3 are both constants.

Well, it does give line 21 in the inspector, but that doesn't make any sense if you go to that line on either compute shader file. Same goes for line 39, which I also looked at.

Double-clicking the errors do not bring me anywhere.

DefaultPlanetGenerator.compute

#pragma kernel Generate
#include "PlanetGeneratorTools.compute"
#include "Noise.compute"

float radius;


float GetUnitHeight(float3 vertex) {

    // TODO:  Write code here!
    float height = Noise(vertex) * 10;
    return height;

}

[numthreads(1, 1, 1)]
void Generate (uint3 id : SV_DispatchThreadID) {

    // Get vertex.
    int index = GetIndex(id);
    float3 vertex = vertices[index];
    // Set vertex to height.
    vertices[index] = vertex * GetUnitHeight(vertex) * radius;

}

Noise.compute

/*
 *
 * This code is a translation of the original code found below to work as a compute shader function.
 * Original .cs file from https://github.com/SebLague/Procedural-Planets/blob/master/Procedural%20Planet%20Noise/Noise.cs
 *
 */

const int noise_size = 256;
const int noise_source[] = {
    151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142,
    8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203,
    117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165,
    71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41,
    55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89,
    18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250,
    124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189,
    28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9,
    129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34,
    242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107, 49, 192, 214, 31,
    181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114,
    67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180
};

const double Sqrt3 = 1.7320508075688772935;
const double Sqrt5 = 2.2360679774997896964;
const double F2 =    0.3660254037844386467;
const double G2 =    0.2113248654051871177;
const double G22 =  -0.5773502691896257645;
const double F3 =    0.3333333333333333333;
const double G3 =    0.1666666666666666666;
const double F4 =    0.3090169943749474241;
const double G4 =    0.1381966011250105151;
const double G42 =   0.2763932022500210303;
const double G43 =   0.4145898033750315455;
const double G44 =  -0.4472135954999579392;

const int Grad3[][3] = {
    {+1, +1, 0}, {-1, +1, 0}, {+1, -1, 0},
    {-1, -1, 0}, {+1, 0, +1}, {-1, 0, +1},
    {+1, 0, -1}, {-1, 0, -1}, {0, +1, +1},
    {0, -1, +1}, {0, +1, -1}, {0, -1, -1}
};




int noise_seed;
int noise_random[512];


float Noise(double3 position);
void Randomize(int seed);
int FastFloor(double x);
void UnpackLittleUint32(int value, int buffer[4]);




/// <summary>
/// Generates value, typically in range [-1, 1]
/// </summary>
float Noise(double3 position) {

    double x = position.x;
    double y = position.y;
    double z = position.z;
    double n0 = 0, n1 = 0, n2 = 0, n3 = 0;

    // Noise contributions from the four corners
    // Skew the input space to determine which simplex cell we're in
    double s = (x + y + z) * F3;

    // for 3D
    int i = FastFloor(x + s);
    int j = FastFloor(y + s);
    int k = FastFloor(z + s);

    double t = (i + j + k) * G3;

    // The x,y,z distances from the cell origin
    double x0 = x - (i - t);
    double y0 = y - (j - t);
    double z0 = z - (k - t);

    // For the 3D case, the simplex shape is a slightly irregular tetrahedron.
    // Determine which simplex we are in.
    // Offsets for second corner of simplex in (i,j,k)
    int i1, j1, k1;

    // coords
    int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords

    if (x0 >= y0)
    {
        if (y0 >= z0)
        {
            // X Y Z order
            i1 = 1;
            j1 = 0;
            k1 = 0;
            i2 = 1;
            j2 = 1;
            k2 = 0;
        }
        else if (x0 >= z0)
        {
            // X Z Y order
            i1 = 1;
            j1 = 0;
            k1 = 0;
            i2 = 1;
            j2 = 0;
            k2 = 1;
        }
        else
        {
            // Z X Y order
            i1 = 0;
            j1 = 0;
            k1 = 1;
            i2 = 1;
            j2 = 0;
            k2 = 1;
        }
    }
    else
    {
        // x0 < y0
        if (y0 < z0)
        {
            // Z Y X order
            i1 = 0;
            j1 = 0;
            k1 = 1;
            i2 = 0;
            j2 = 1;
            k2 = 1;
        }
        else if (x0 < z0)
        {
            // Y Z X order
            i1 = 0;
            j1 = 1;
            k1 = 0;
            i2 = 0;
            j2 = 1;
            k2 = 1;
        }
        else
        {
            // Y X Z order
            i1 = 0;
            j1 = 1;
            k1 = 0;
            i2 = 1;
            j2 = 1;
            k2 = 0;
        }
    }

    // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
    // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z),
    // and
    // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z),
    // where c = 1/6.

    // Offsets for second corner in (x,y,z) coords
    double x1 = x0 - i1 + G3;
    double y1 = y0 - j1 + G3;
    double z1 = z0 - k1 + G3;

    // Offsets for third corner in (x,y,z)
    double x2 = x0 - i2 + F3;
    double y2 = y0 - j2 + F3;
    double z2 = z0 - k2 + F3;

    // Offsets for last corner in (x,y,z)
    double x3 = x0 - 0.5;
    double y3 = y0 - 0.5;
    double z3 = z0 - 0.5;

    // Work out the hashed gradient indices of the four simplex corners
    int ii = i & 0xff;
    int jj = j & 0xff;
    int kk = k & 0xff;

    // Calculate the contribution from the four corners
    double t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
    if (t0 > 0) {

        t0 *= t0;
        int gi0 = noise_random[ii + noise_random[jj + noise_random[kk]]] % 12;
        n0 = t0 * t0 * dot(double3(Grad3[gi0][0], Grad3[gi0][1], Grad3[gi0][2]), double3(x0, y0, z0));

    }

    double t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
    if (t1 > 0) {

        t1 *= t1;
        int gi1 = noise_random[ii + i1 + noise_random[jj + j1 + noise_random[kk + k1]]] % 12;
        n1 = t1 * t1 * dot(double3(Grad3[gi1][0], Grad3[gi1][1], Grad3[gi1][2]), double3(x1, y1, z1));

    }

    double t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
    if (t2 > 0) {

        t2 *= t2;
        int gi2 = noise_random[ii + i2 + noise_random[jj + j2 + noise_random[kk + k2]]] % 12;
        n2 = t2 * t2 * dot(double3(Grad3[gi2][0], Grad3[gi2][1], Grad3[gi2][2]), double3(x2, y2, z2));

    }

    double t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
    if (t3 > 0) {

        t3 *= t3;
        int gi3 = noise_random[ii + 1 + noise_random[jj + 1 + noise_random[kk + 1]]] % 12;
        n3 = t3 * t3 * dot(double3(Grad3[gi3][0], Grad3[gi3][1], Grad3[gi3][2]), double3(x3, y3, z3));

    }

    // Add contributions from each corner to get the final noise value.
    // The result is scaled to stay just inside [-1,1]
    return (float)(n0 + n1 + n2 + n3) * 32;

}

int FastFloor(double x) {
    if (x >= 0) return (int)x;
    else return (int)x - 1;
}

void UpackLittleUint32(int value, int buffer[4]) {
    buffer[0] = value & 0x000000ff % 255;
    buffer[1] = value & 0x0000ff00 % 255;
    buffer[2] = value & 0x00ff0000 % 255;
    buffer[3] = value & 0xff000000 % 255;
}

void Randomize(int seed) {
    
    if (seed != 0) {

        int F[4];
        UnpackLittleUint32(seed, F);

        for (int i = 0; i < noise_size; i++) {
            noise_random[i] = noise_source[i] ^ F[0] ^ F[1] ^ F[2] ^ F[3];
            noise_random[i + noise_size] = noise_random[i];
        }

    }

    else {

        for (int i = 0; i < noise_size; i++) {
            noise_random[i + noise_size] = noise_random[i] = noise_source[i];
        }

    }

}

Replacing all double types with float types solved the issue.